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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.335
+Version: 0.0.337
 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.337}/code_puppy/http_utils.py

@@ -5,10 +5,10 @@ This module provides functions for creating properly configured HTTP clients.
 """
 
 import asyncio
-import logging
 import os
 import socket
 import time
+from dataclasses import dataclass
 from typing import Any, Dict, Optional, Union
 
 import httpx
@@ -16,7 +16,69 @@ import requests
 
 from code_puppy.config import get_http2
 
-logger = logging.getLogger(__name__)
+
+@dataclass
+class ProxyConfig:
+    """Configuration for proxy and SSL settings."""
+
+    verify: Union[bool, str, None]
+    trust_env: bool
+    proxy_url: str | None
+    disable_retry: bool
+    http2_enabled: bool
+
+
+def _resolve_proxy_config(verify: Union[bool, str, None] = None) -> ProxyConfig:
+    """Resolve proxy, SSL, and retry settings from environment.
+
+    This centralizes the logic for detecting proxies, determining SSL verification,
+    and checking if retry transport should be disabled.
+    """
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    http2_enabled = get_http2()
+
+    disable_retry = os.environ.get(
+        "CODE_PUPPY_DISABLE_RETRY_TRANSPORT", ""
+    ).lower() in ("1", "true", "yes")
+
+    has_proxy = bool(
+        os.environ.get("HTTP_PROXY")
+        or os.environ.get("HTTPS_PROXY")
+        or os.environ.get("http_proxy")
+        or os.environ.get("https_proxy")
+    )
+
+    # Determine trust_env and verify based on proxy/retry settings
+    if disable_retry:
+        # Test mode: disable SSL verification for proxy testing
+        verify = False
+        trust_env = True
+    elif has_proxy:
+        # Production proxy: keep SSL verification enabled
+        trust_env = True
+    else:
+        trust_env = False
+
+    # Extract proxy URL
+    proxy_url = None
+    if has_proxy:
+        proxy_url = (
+            os.environ.get("HTTPS_PROXY")
+            or os.environ.get("https_proxy")
+            or os.environ.get("HTTP_PROXY")
+            or os.environ.get("http_proxy")
+        )
+
+    return ProxyConfig(
+        verify=verify,
+        trust_env=trust_env,
+        proxy_url=proxy_url,
+        disable_retry=disable_retry,
+        http2_enabled=http2_enabled,
+    )
+
 
 try:
     from .reopenable_async_client import ReopenableAsyncClient
@@ -58,14 +120,7 @@ class RetryingAsyncClient(httpx.AsyncClient):
 
         for attempt in range(self.max_retries + 1):
             try:
-                # Clone request for retry (streams might be consumed)
-                # But only if it's not the first attempt
-                req_to_send = request
-                if attempt > 0:
-                    # httpx requests are reusable, but we need to be careful with streams
-                    pass
-
-                response = await super().send(req_to_send, **kwargs)
+                response = await super().send(request, **kwargs)
                 last_response = response
 
                 # Check for retryable status
@@ -128,7 +183,7 @@ class RetryingAsyncClient(httpx.AsyncClient):
         return last_response
 
 
-def get_cert_bundle_path() -> str:
+def get_cert_bundle_path() -> str | None:
     # First check if SSL_CERT_FILE environment variable is set
     ssl_cert_file = os.environ.get("SSL_CERT_FILE")
     if ssl_cert_file and os.path.exists(ssl_cert_file):
@@ -164,66 +219,26 @@ def create_async_client(
     headers: Optional[Dict[str, str]] = None,
     retry_status_codes: tuple = (429, 502, 503, 504),
 ) -> httpx.AsyncClient:
-    if verify is None:
-        verify = get_cert_bundle_path()
-
-    # Check if HTTP/2 is enabled in config
-    http2_enabled = get_http2()
-
-    # Check if custom retry transport should be disabled (e.g., for integration tests with proxies)
-    disable_retry_transport = os.environ.get(
-        "CODE_PUPPY_DISABLE_RETRY_TRANSPORT", ""
-    ).lower() in ("1", "true", "yes")
-
-    # Check if proxy environment variables are set
-    has_proxy = bool(
-        os.environ.get("HTTP_PROXY")
-        or os.environ.get("HTTPS_PROXY")
-        or os.environ.get("http_proxy")
-        or os.environ.get("https_proxy")
-    )
-
-    # When retry transport is disabled (test mode), disable SSL verification
-    # for proxy testing. For production proxies, SSL should still be verified!
-    if disable_retry_transport:
-        verify = False
-        trust_env = True
-    elif has_proxy:
-        # Production proxy detected - keep SSL verification enabled for security
-        trust_env = True
-    else:
-        trust_env = False
-
-    # Extract proxy URL if needed
-    proxy_url = None
-    if has_proxy:
-        proxy_url = (
-            os.environ.get("HTTPS_PROXY")
-            or os.environ.get("https_proxy")
-            or os.environ.get("HTTP_PROXY")
-            or os.environ.get("http_proxy")
-        )
+    config = _resolve_proxy_config(verify)
 
-    # Use RetryingAsyncClient if retries are enabled
-    if not disable_retry_transport:
+    if not config.disable_retry:
         return RetryingAsyncClient(
             retry_status_codes=retry_status_codes,
-            proxy=proxy_url,
-            verify=verify,
+            proxy=config.proxy_url,
+            verify=config.verify,
             headers=headers or {},
             timeout=timeout,
-            http2=http2_enabled,
-            trust_env=trust_env,
+            http2=config.http2_enabled,
+            trust_env=config.trust_env,
         )
     else:
-        # Regular client for testing
         return httpx.AsyncClient(
-            proxy=proxy_url,
-            verify=verify,
+            proxy=config.proxy_url,
+            verify=config.verify,
             headers=headers or {},
             timeout=timeout,
-            http2=http2_enabled,
-            trust_env=trust_env,
+            http2=config.http2_enabled,
+            trust_env=config.trust_env,
         )
 
 
@@ -273,85 +288,33 @@ def create_reopenable_async_client(
     headers: Optional[Dict[str, str]] = None,
     retry_status_codes: tuple = (429, 502, 503, 504),
 ) -> Union[ReopenableAsyncClient, httpx.AsyncClient]:
-    if verify is None:
-        verify = get_cert_bundle_path()
-
-    # Check if HTTP/2 is enabled in config
-    http2_enabled = get_http2()
-
-    # Check if custom retry transport should be disabled (e.g., for integration tests with proxies)
-    disable_retry_transport = os.environ.get(
-        "CODE_PUPPY_DISABLE_RETRY_TRANSPORT", ""
-    ).lower() in ("1", "true", "yes")
-
-    # Check if proxy environment variables are set
-    has_proxy = bool(
-        os.environ.get("HTTP_PROXY")
-        or os.environ.get("HTTPS_PROXY")
-        or os.environ.get("http_proxy")
-        or os.environ.get("https_proxy")
-    )
-
-    # When retry transport is disabled (test mode), disable SSL verification
-    if disable_retry_transport:
-        verify = False
-        trust_env = True
-    elif has_proxy:
-        trust_env = True
-    else:
-        trust_env = False
+    config = _resolve_proxy_config(verify)
 
-    # Extract proxy URL if needed
-    proxy_url = None
-    if has_proxy:
-        proxy_url = (
-            os.environ.get("HTTPS_PROXY")
-            or os.environ.get("https_proxy")
-            or os.environ.get("HTTP_PROXY")
-            or os.environ.get("http_proxy")
-        )
+    base_kwargs = {
+        "proxy": config.proxy_url,
+        "verify": config.verify,
+        "headers": headers or {},
+        "timeout": timeout,
+        "http2": config.http2_enabled,
+        "trust_env": config.trust_env,
+    }
 
     if ReopenableAsyncClient is not None:
-        # Use RetryingAsyncClient if retries are enabled
         client_class = (
-            RetryingAsyncClient if not disable_retry_transport else httpx.AsyncClient
+            RetryingAsyncClient if not config.disable_retry else httpx.AsyncClient
         )
-
-        # Pass retry config only if using RetryingAsyncClient
-        kwargs = {
-            "proxy": proxy_url,
-            "verify": verify,
-            "headers": headers or {},
-            "timeout": timeout,
-            "http2": http2_enabled,
-            "trust_env": trust_env,
-        }
-
-        if not disable_retry_transport:
+        kwargs = {**base_kwargs, "client_class": client_class}
+        if not config.disable_retry:
             kwargs["retry_status_codes"] = retry_status_codes
-
-        return ReopenableAsyncClient(client_class=client_class, **kwargs)
+        return ReopenableAsyncClient(**kwargs)
     else:
-        # Fallback to RetryingAsyncClient
-        if not disable_retry_transport:
+        # Fallback to RetryingAsyncClient or plain AsyncClient
+        if not config.disable_retry:
             return RetryingAsyncClient(
-                retry_status_codes=retry_status_codes,
-                proxy=proxy_url,
-                verify=verify,
-                headers=headers or {},
-                timeout=timeout,
-                http2=http2_enabled,
-                trust_env=trust_env,
+                retry_status_codes=retry_status_codes, **base_kwargs
             )
         else:
-            return httpx.AsyncClient(
-                proxy=proxy_url,
-                verify=verify,
-                headers=headers or {},
-                timeout=timeout,
-                http2=http2_enabled,
-                trust_env=trust_env,
-            )
+            return httpx.AsyncClient(**base_kwargs)
 
 
 def is_cert_bundle_available() -> bool:

{code_puppy-0.0.335 → code_puppy-0.0.337}/code_puppy/messaging/messages.py

@@ -209,6 +209,9 @@ class ShellStartMessage(BaseMessage):
         default=None, description="Working directory for the command"
     )
     timeout: int = Field(default=60, description="Timeout in seconds")
+    background: bool = Field(
+        default=False, description="Whether command runs in background mode"
+    )
 
 
 class ShellLineMessage(BaseMessage):

{code_puppy-0.0.335 → code_puppy-0.0.337}/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(
@@ -538,15 +620,25 @@ class RichConsoleRenderer:
         safe_command = escape_rich_markup(msg.command)
         # Header showing command is starting
         banner = self._format_banner("shell_command", "SHELL COMMAND")
-        self._console.print(f"\n{banner} 🚀 [dim]$ {safe_command}[/dim]")
+
+        # Add background indicator if running in background mode
+        if msg.background:
+            self._console.print(
+                f"\n{banner} 🚀 [dim]$ {safe_command}[/dim]  [bold magenta][BACKGROUND 🌙][/bold magenta]"
+            )
+        else:
+            self._console.print(f"\n{banner} 🚀 [dim]$ {safe_command}[/dim]")
 
         # Show working directory if specified
         if msg.cwd:
             safe_cwd = escape_rich_markup(msg.cwd)
             self._console.print(f"[dim]📂 Working directory: {safe_cwd}[/dim]")
 
-        # Show timeout
-        self._console.print(f"[dim]⏱ Timeout: {msg.timeout}s[/dim]")
+        # Show timeout or background status
+        if msg.background:
+            self._console.print("[dim]⏱ Runs detached (no timeout)[/dim]")
+        else:
+            self._console.print(f"[dim]⏱ Timeout: {msg.timeout}s[/dim]")
 
     def _render_shell_line(self, msg: ShellLineMessage) -> None:
         """Render shell output line preserving ANSI codes."""

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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import base64
 import json
 import logging
 from collections.abc import AsyncIterator
@@ -54,7 +55,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] = []
 
@@ -67,7 +76,16 @@ class AntigravityModel(GoogleModel):
                         system_parts.append({"text": part.content})
                     elif isinstance(part, UserPromptPart):
                         # Use parent's _map_user_prompt
-                        message_parts.extend(await self._map_user_prompt(part))
+                        mapped_parts = await self._map_user_prompt(part)
+                        # Sanitize bytes to base64 for JSON serialization
+                        for mp in mapped_parts:
+                            if "inline_data" in mp and "data" in mp["inline_data"]:
+                                data = mp["inline_data"]["data"]
+                                if isinstance(data, bytes):
+                                    mp["inline_data"]["data"] = base64.b64encode(
+                                        data
+                                    ).decode("utf-8")
+                        message_parts.extend(mapped_parts)
                     elif isinstance(part, ToolReturnPart):
                         message_parts.append(
                             {
@@ -95,7 +113,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 +126,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 +462,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 +477,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 +489,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 +501,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 +537,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
@@ -501,8 +552,13 @@ def _antigravity_content_model_response(
 
         elif isinstance(item, FilePart):
             content = item.content
+            # Ensure data is base64 string, not bytes
+            data_val = content.data
+            if isinstance(data_val, bytes):
+                data_val = base64.b64encode(data_val).decode("utf-8")
+
             inline_data_dict: BlobDict = {
-                "data": content.data,
+                "data": data_val,
                 "mime_type": content.media_type,
             }
             part["inline_data"] = inline_data_dict