code-puppy 0.0.336__py3-none-any.whl → 0.0.338__py3-none-any.whl

code_puppy/agents/base_agent.py

@@ -1353,7 +1353,6 @@ class BaseAgent(ABC):
             ToolCallPartDelta,
         )
         from rich.console import Console
-        from rich.markdown import Markdown
         from rich.markup import escape
 
         from code_puppy.messaging.spinner import pause_all_spinners
@@ -1375,10 +1374,17 @@ class BaseAgent(ABC):
         text_parts: set[int] = set()  # Track which parts are text
         tool_parts: set[int] = set()  # Track which parts are tool calls
         banner_printed: set[int] = set()  # Track if banner was already printed
-        text_buffer: dict[int, list[str]] = {}  # Buffer text for final markdown render
         token_count: dict[int, int] = {}  # Track token count per text/tool part
         did_stream_anything = False  # Track if we streamed any content
 
+        # Termflow streaming state for text parts
+        from termflow import Parser as TermflowParser
+        from termflow import Renderer as TermflowRenderer
+
+        termflow_parsers: dict[int, TermflowParser] = {}
+        termflow_renderers: dict[int, TermflowRenderer] = {}
+        termflow_line_buffers: dict[int, str] = {}  # Buffer incomplete lines
+
         def _print_thinking_banner() -> None:
             """Print the THINKING banner with spinner pause and line clear."""
             nonlocal did_stream_anything
@@ -1437,13 +1443,17 @@ class BaseAgent(ABC):
                 elif isinstance(part, TextPart):
                     streaming_parts.add(event.index)
                     text_parts.add(event.index)
-                    text_buffer[event.index] = []  # Initialize buffer
-                    token_count[event.index] = 0  # Initialize token counter
-                    # Buffer initial content if present
+                    # Initialize termflow streaming for this text part
+                    termflow_parsers[event.index] = TermflowParser()
+                    termflow_renderers[event.index] = TermflowRenderer(
+                        output=console.file, width=console.width
+                    )
+                    termflow_line_buffers[event.index] = ""
+                    # Handle initial content if present
                     if part.content and part.content.strip():
-                        text_buffer[event.index].append(part.content)
-                        # Count chunks (each part counts as 1)
-                        token_count[event.index] += 1
+                        _print_response_banner()
+                        banner_printed.add(event.index)
+                        termflow_line_buffers[event.index] = part.content
                 elif isinstance(part, ToolCallPart):
                     streaming_parts.add(event.index)
                     tool_parts.add(event.index)
@@ -1459,22 +1469,29 @@ class BaseAgent(ABC):
                     delta = event.delta
                     if isinstance(delta, (TextPartDelta, ThinkingPartDelta)):
                         if delta.content_delta:
-                            # For text parts, show token counter then render at end
+                            # For text parts, stream markdown with termflow
                             if event.index in text_parts:
                                 # Print banner on first content
                                 if event.index not in banner_printed:
                                     _print_response_banner()
                                     banner_printed.add(event.index)
-                                # Accumulate text for final markdown render
-                                text_buffer[event.index].append(delta.content_delta)
-                                # Count chunks received
-                                token_count[event.index] += 1
-                                # Update chunk counter in place (single line)
-                                count = token_count[event.index]
-                                console.print(
-                                    f"  ⏳ Receiving... {count} chunks   ",
-                                    end="\r",
+
+                                # Add content to line buffer
+                                termflow_line_buffers[event.index] += (
+                                    delta.content_delta
                                 )
+
+                                # Process complete lines
+                                parser = termflow_parsers[event.index]
+                                renderer = termflow_renderers[event.index]
+                                buffer = termflow_line_buffers[event.index]
+
+                                while "\n" in buffer:
+                                    line, buffer = buffer.split("\n", 1)
+                                    events_to_render = parser.parse_line(line)
+                                    renderer.render_all(events_to_render)
+
+                                termflow_line_buffers[event.index] = buffer
                             else:
                                 # For thinking parts, stream immediately (dim)
                                 if event.index not in banner_printed:
@@ -1503,19 +1520,27 @@ class BaseAgent(ABC):
             # PartEndEvent - finish the streaming with a newline
             elif isinstance(event, PartEndEvent):
                 if event.index in streaming_parts:
-                    # For text parts, clear counter line and render markdown
+                    # For text parts, finalize termflow rendering
                     if event.index in text_parts:
-                        # Clear the chunk counter line by printing spaces and returning
-                        console.print(" " * 50, end="\r")
-                        # Render the final markdown nicely
-                        if event.index in text_buffer:
-                            try:
-                                final_content = "".join(text_buffer[event.index])
-                                if final_content.strip():
-                                    console.print(Markdown(final_content))
-                            except Exception:
-                                pass
-                            del text_buffer[event.index]
+                        # Render any remaining buffered content
+                        if event.index in termflow_parsers:
+                            parser = termflow_parsers[event.index]
+                            renderer = termflow_renderers[event.index]
+                            remaining = termflow_line_buffers.get(event.index, "")
+
+                            # Parse and render any remaining partial line
+                            if remaining.strip():
+                                events_to_render = parser.parse_line(remaining)
+                                renderer.render_all(events_to_render)
+
+                            # Finalize the parser to close any open blocks
+                            final_events = parser.finalize()
+                            renderer.render_all(final_events)
+
+                            # Clean up termflow state
+                            del termflow_parsers[event.index]
+                            del termflow_renderers[event.index]
+                            del termflow_line_buffers[event.index]
                     # For tool parts, clear the chunk counter line
                     elif event.index in tool_parts:
                         # Clear the chunk counter line by printing spaces and returning

code_puppy/claude_cache_client.py

@@ -10,7 +10,7 @@ serialization, avoiding httpx/Pydantic internals.
 from __future__ import annotations
 
 import json
-from typing import Any, Callable
+from typing import Any, Callable, MutableMapping
 
 import httpx
 
@@ -56,7 +56,28 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         except Exception:
             # Swallow wrapper errors; do not break real calls.
             pass
-        return await super().send(request, *args, **kwargs)
+        response = await super().send(request, *args, **kwargs)
+        try:
+            if response.status_code == 401 and not request.extensions.get(
+                "claude_oauth_refresh_attempted"
+            ):
+                refreshed_token = self._refresh_claude_oauth_token()
+                if refreshed_token:
+                    await response.aclose()
+                    body_bytes = self._extract_body_bytes(request)
+                    headers = dict(request.headers)
+                    self._update_auth_headers(headers, refreshed_token)
+                    retry_request = self.build_request(
+                        method=request.method,
+                        url=request.url,
+                        headers=headers,
+                        content=body_bytes,
+                    )
+                    retry_request.extensions["claude_oauth_refresh_attempted"] = True
+                    return await super().send(retry_request, *args, **kwargs)
+        except Exception:
+            pass
+        return response
 
     @staticmethod
     def _extract_body_bytes(request: httpx.Request) -> bytes | None:
@@ -78,6 +99,29 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
 
         return None
 
+    @staticmethod
+    def _update_auth_headers(
+        headers: MutableMapping[str, str], access_token: str
+    ) -> None:
+        bearer_value = f"Bearer {access_token}"
+        if "Authorization" in headers or "authorization" in headers:
+            headers["Authorization"] = bearer_value
+        elif "x-api-key" in headers or "X-API-Key" in headers:
+            headers["x-api-key"] = access_token
+        else:
+            headers["Authorization"] = bearer_value
+
+    def _refresh_claude_oauth_token(self) -> str | None:
+        try:
+            from code_puppy.plugins.claude_code_oauth.utils import refresh_access_token
+
+            refreshed_token = refresh_access_token(force=True)
+            if refreshed_token:
+                self._update_auth_headers(self.headers, refreshed_token)
+            return refreshed_token
+        except Exception:
+            return None
+
     @staticmethod
     def _inject_cache_control(body: bytes) -> bytes | None:
         try:

code_puppy/cli_runner.py

@@ -17,10 +17,7 @@ import traceback
 from pathlib import Path
 
 from dbos import DBOS, DBOSConfig
-from rich.console import Console, ConsoleOptions, RenderResult
-from rich.markdown import CodeBlock, Markdown
-from rich.syntax import Syntax
-from rich.text import Text
+from rich.console import Console
 
 from code_puppy import __version__, callbacks, plugins
 from code_puppy.agents import get_current_agent
@@ -43,6 +40,7 @@ from code_puppy.keymap import (
 )
 from code_puppy.messaging import emit_info
 from code_puppy.terminal_utils import (
+    print_truecolor_warning,
     reset_unix_terminal,
     reset_windows_terminal_ansi,
     reset_windows_terminal_full,
@@ -91,7 +89,6 @@ async def main():
         "command", nargs="*", help="Run a single command (deprecated, use -p instead)"
     )
     args = parser.parse_args()
-    from rich.console import Console
 
     from code_puppy.messaging import (
         RichConsoleRenderer,
@@ -146,6 +143,9 @@ async def main():
         except ImportError:
             emit_system_message("🐶 Code Puppy is Loading...")
 
+        # Check for truecolor support and warn if not available
+        print_truecolor_warning(display_console)
+
     available_port = find_available_port()
     if available_port is None:
         emit_error("No available ports in range 8090-9010!")
@@ -679,8 +679,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             save_command_to_history(task)
 
             try:
-                prettier_code_blocks()
-
                 # No need to get agent directly - use manager's run methods
 
                 # Use our custom helper to enable attachment handling with spinner support
@@ -750,28 +748,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 pass
 
 
-def prettier_code_blocks():
-    """Configure Rich to use prettier code block rendering."""
-
-    class SimpleCodeBlock(CodeBlock):
-        def __rich_console__(
-            self, console: Console, options: ConsoleOptions
-        ) -> RenderResult:
-            code = str(self.text).rstrip()
-            yield Text(self.lexer_name, style="dim")
-            syntax = Syntax(
-                code,
-                self.lexer_name,
-                theme=self.theme,
-                background_color="default",
-                line_numbers=True,
-            )
-            yield syntax
-            yield Text(f"/{self.lexer_name}", style="dim")
-
-    Markdown.elements["fence"] = SimpleCodeBlock
-
-
 async def run_prompt_with_attachments(
     agent,
     raw_prompt: str,

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/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/messaging/rich_renderer.py

@@ -620,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/model_factory.py

@@ -388,6 +388,20 @@ class ModelFactory:
             return AnthropicModel(model_name=model_config["name"], provider=provider)
         elif model_type == "claude_code":
             url, headers, verify, api_key = get_custom_config(model_config)
+            if model_config.get("oauth_source") == "claude-code-plugin":
+                try:
+                    from code_puppy.plugins.claude_code_oauth.utils import (
+                        get_valid_access_token,
+                    )
+
+                    refreshed_token = get_valid_access_token()
+                    if refreshed_token:
+                        api_key = refreshed_token
+                        custom_endpoint = model_config.get("custom_endpoint")
+                        if isinstance(custom_endpoint, dict):
+                            custom_endpoint["api_key"] = refreshed_token
+                except ImportError:
+                    pass
             if not api_key:
                 emit_warning(
                     f"API key is not set for Claude Code endpoint; skipping model '{model_config.get('name')}'."
@@ -663,6 +677,8 @@ class ModelFactory:
                     f"API key is not set for Cerebras endpoint; skipping model '{model_config.get('name')}'."
                 )
                 return None
+            # Add Cerebras 3rd party integration header
+            headers["X-Cerebras-3rd-Party-Integration"] = "code-puppy"
             client = create_async_client(headers=headers, verify=verify)
             provider_args = dict(
                 api_key=api_key,

code_puppy/models.json

@@ -55,9 +55,9 @@
     "supported_settings": ["reasoning_effort", "verbosity"],
     "supports_xhigh_reasoning": true
   },
-  "Cerebras-GLM-4.6": {
+  "Cerebras-GLM-4.7": {
     "type": "cerebras",
-    "name": "zai-glm-4.6",
+    "name": "zai-glm-4.7",
     "custom_endpoint": {
       "url": "https://api.cerebras.ai/v1",
       "api_key": "$CEREBRAS_API_KEY"

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
@@ -75,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(
                             {
@@ -542,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

code_puppy/plugins/claude_code_oauth/utils.py

@@ -21,6 +21,8 @@ from .config import (
     get_token_storage_path,
 )
 
+TOKEN_REFRESH_BUFFER_SECONDS = 60
+
 logger = logging.getLogger(__name__)
 
 
@@ -132,6 +134,124 @@ def load_stored_tokens() -> Optional[Dict[str, Any]]:
     return None
 
 
+def _calculate_expires_at(expires_in: Optional[float]) -> Optional[float]:
+    if expires_in is None:
+        return None
+    try:
+        return time.time() + float(expires_in)
+    except (TypeError, ValueError):
+        return None
+
+
+def is_token_expired(tokens: Dict[str, Any]) -> bool:
+    expires_at = tokens.get("expires_at")
+    if expires_at is None:
+        return False
+    try:
+        expires_at_value = float(expires_at)
+    except (TypeError, ValueError):
+        return False
+    return time.time() >= expires_at_value - TOKEN_REFRESH_BUFFER_SECONDS
+
+
+def update_claude_code_model_tokens(access_token: str) -> bool:
+    try:
+        claude_models = load_claude_models()
+        if not claude_models:
+            return False
+
+        updated = False
+        for config in claude_models.values():
+            if config.get("oauth_source") != "claude-code-plugin":
+                continue
+            custom_endpoint = config.get("custom_endpoint")
+            if not isinstance(custom_endpoint, dict):
+                continue
+            custom_endpoint["api_key"] = access_token
+            updated = True
+
+        if updated:
+            return save_claude_models(claude_models)
+    except Exception as exc:  # pragma: no cover - defensive logging
+        logger.error("Failed to update Claude model tokens: %s", exc)
+    return False
+
+
+def refresh_access_token(force: bool = False) -> Optional[str]:
+    tokens = load_stored_tokens()
+    if not tokens:
+        return None
+
+    if not force and not is_token_expired(tokens):
+        return tokens.get("access_token")
+
+    refresh_token = tokens.get("refresh_token")
+    if not refresh_token:
+        logger.debug("No refresh_token available")
+        return None
+
+    payload = {
+        "grant_type": "refresh_token",
+        "client_id": CLAUDE_CODE_OAUTH_CONFIG["client_id"],
+        "refresh_token": refresh_token,
+    }
+
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "anthropic-beta": "oauth-2025-04-20",
+    }
+
+    try:
+        response = requests.post(
+            CLAUDE_CODE_OAUTH_CONFIG["token_url"],
+            json=payload,
+            headers=headers,
+            timeout=30,
+        )
+        if response.status_code == 200:
+            new_tokens = response.json()
+            tokens["access_token"] = new_tokens.get("access_token")
+            tokens["refresh_token"] = new_tokens.get("refresh_token", refresh_token)
+            if "expires_in" in new_tokens:
+                tokens["expires_in"] = new_tokens["expires_in"]
+                tokens["expires_at"] = _calculate_expires_at(
+                    new_tokens.get("expires_in")
+                )
+            if save_tokens(tokens):
+                update_claude_code_model_tokens(tokens["access_token"])
+                return tokens["access_token"]
+        else:
+            logger.error(
+                "Token refresh failed: %s - %s", response.status_code, response.text
+            )
+    except Exception as exc:  # pragma: no cover - defensive logging
+        logger.error("Token refresh error: %s", exc)
+    return None
+
+
+def get_valid_access_token() -> Optional[str]:
+    tokens = load_stored_tokens()
+    if not tokens:
+        logger.debug("No stored Claude Code OAuth tokens found")
+        return None
+
+    access_token = tokens.get("access_token")
+    if not access_token:
+        logger.debug("No access_token in stored tokens")
+        return None
+
+    if is_token_expired(tokens):
+        logger.info("Claude Code OAuth token expired, attempting refresh")
+        refreshed = refresh_access_token()
+        if refreshed:
+            return refreshed
+        logger.warning("Claude Code token refresh failed")
+        return None
+
+    return access_token
+
+
 def save_tokens(tokens: Dict[str, Any]) -> bool:
     try:
         token_path = get_token_storage_path()
@@ -243,7 +363,11 @@ def exchange_code_for_tokens(
         logger.info("Token exchange response: %s", response.status_code)
         logger.debug("Response body: %s", response.text)
         if response.status_code == 200:
-            return response.json()
+            token_data = response.json()
+            token_data["expires_at"] = _calculate_expires_at(
+                token_data.get("expires_in")
+            )
+            return token_data
         logger.error(
             "Token exchange failed: %s - %s",
             response.status_code,
@@ -341,12 +465,7 @@ def add_models_to_extra_config(models: List[str]) -> bool:
         # Start fresh - overwrite the file on every auth instead of loading existing
         claude_models = {}
         added = 0
-        tokens = load_stored_tokens()
-
-        # Handle case where tokens are None or empty
-        access_token = ""
-        if tokens and "access_token" in tokens:
-            access_token = tokens["access_token"]
+        access_token = get_valid_access_token() or ""
 
         for model_name in filtered_models:
             prefixed = f"{CLAUDE_CODE_OAUTH_CONFIG['prefix']}{model_name}"

code_puppy/terminal_utils.py

@@ -3,10 +3,14 @@
 Handles Windows console mode resets and Unix terminal sanity restoration.
 """
 
+import os
 import platform
 import subprocess
 import sys
-from typing import Callable, Optional
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:
+    from rich.console import Console
 
 # Store the original console ctrl handler so we can restore it if needed
 _original_ctrl_handler: Optional[Callable] = None
@@ -289,3 +293,126 @@ def ensure_ctrl_c_disabled() -> bool:
 
     except Exception:
         return False
+
+
+def detect_truecolor_support() -> bool:
+    """Detect if the terminal supports truecolor (24-bit color).
+
+    Checks multiple indicators:
+    1. COLORTERM environment variable (most reliable)
+    2. TERM environment variable patterns
+    3. Rich's Console color_system detection as fallback
+
+    Returns:
+        True if truecolor is supported, False otherwise.
+    """
+    # Check COLORTERM - this is the most reliable indicator
+    colorterm = os.environ.get("COLORTERM", "").lower()
+    if colorterm in ("truecolor", "24bit"):
+        return True
+
+    # Check TERM for known truecolor-capable terminals
+    term = os.environ.get("TERM", "").lower()
+    truecolor_terms = (
+        "xterm-direct",
+        "xterm-truecolor",
+        "iterm2",
+        "vte-256color",  # Many modern terminals set this
+    )
+    if any(t in term for t in truecolor_terms):
+        return True
+
+    # Some terminals like iTerm2, Kitty, Alacritty set specific env vars
+    if os.environ.get("ITERM_SESSION_ID"):
+        return True
+    if os.environ.get("KITTY_WINDOW_ID"):
+        return True
+    if os.environ.get("ALACRITTY_SOCKET"):
+        return True
+    if os.environ.get("WT_SESSION"):  # Windows Terminal
+        return True
+
+    # Use Rich's detection as a fallback
+    try:
+        from rich.console import Console
+
+        console = Console(force_terminal=True)
+        color_system = console.color_system
+        return color_system == "truecolor"
+    except Exception:
+        pass
+
+    return False
+
+
+def print_truecolor_warning(console: Optional["Console"] = None) -> None:
+    """Print a big fat red warning if truecolor is not supported.
+
+    Args:
+        console: Optional Rich Console instance. If None, creates a new one.
+    """
+    if detect_truecolor_support():
+        return  # All good, no warning needed
+
+    if console is None:
+        try:
+            from rich.console import Console
+
+            console = Console()
+        except ImportError:
+            # Rich not available, fall back to plain print
+            print("\n" + "=" * 70)
+            print("⚠️  WARNING: TERMINAL DOES NOT SUPPORT TRUECOLOR (24-BIT COLOR)")
+            print("=" * 70)
+            print("Code Puppy looks best with truecolor support.")
+            print("Consider using a modern terminal like:")
+            print("  • iTerm2 (macOS)")
+            print("  • Windows Terminal (Windows)")
+            print("  • Kitty, Alacritty, or any modern terminal emulator")
+            print("")
+            print("You can also try setting: export COLORTERM=truecolor")
+            print("")
+            print("Note: The built-in macOS Terminal.app does not support truecolor")
+            print("(Sequoia and earlier). You'll need a different terminal app.")
+            print("=" * 70 + "\n")
+            return
+
+    # Get detected color system for diagnostic info
+    color_system = console.color_system or "unknown"
+
+    # Build the warning box
+    warning_lines = [
+        "",
+        "[bold bright_red on red]" + "━" * 72 + "[/]",
+        "[bold bright_red on red]┃[/][bold bright_white on red]"
+        + " " * 70
+        + "[/][bold bright_red on red]┃[/]",
+        "[bold bright_red on red]┃[/][bold bright_white on red]  ⚠️   WARNING: TERMINAL DOES NOT SUPPORT TRUECOLOR (24-BIT COLOR)  ⚠️   [/][bold bright_red on red]┃[/]",
+        "[bold bright_red on red]┃[/][bold bright_white on red]"
+        + " " * 70
+        + "[/][bold bright_red on red]┃[/]",
+        "[bold bright_red on red]" + "━" * 72 + "[/]",
+        "",
+        f"[yellow]Detected color system:[/] [bold]{color_system}[/]",
+        "",
+        "[bold white]Code Puppy uses rich colors and will look degraded without truecolor.[/]",
+        "",
+        "[cyan]Consider using a modern terminal emulator:[/]",
+        "  [green]•[/] [bold]iTerm2[/] (macOS) - https://iterm2.com",
+        "  [green]•[/] [bold]Windows Terminal[/] (Windows) - Built into Windows 11",
+        "  [green]•[/] [bold]Kitty[/] - https://sw.kovidgoyal.net/kitty",
+        "  [green]•[/] [bold]Alacritty[/] - https://alacritty.org",
+        "  [green]•[/] [bold]Warp[/] (macOS) - https://warp.dev",
+        "",
+        "[cyan]Or try setting the COLORTERM environment variable:[/]",
+        "  [dim]export COLORTERM=truecolor[/]",
+        "",
+        "[dim italic]Note: The built-in macOS Terminal.app does not support truecolor (Sequoia and earlier).[/]",
+        "[dim italic]Setting COLORTERM=truecolor won't help - you'll need a different terminal app.[/]",
+        "",
+        "[bold bright_red]" + "─" * 72 + "[/]",
+        "",
+    ]
+
+    for line in warning_lines:
+        console.print(line)

code_puppy/tools/command_runner.py

@@ -880,6 +880,7 @@ async def run_shell_command(
                     command=command,
                     cwd=cwd,
                     timeout=0,  # No timeout for background processes
+                    background=True,
                 )
             )
 

{code_puppy-0.0.336.data → code_puppy-0.0.338.data}/data/code_puppy/models.json

@@ -55,9 +55,9 @@
     "supported_settings": ["reasoning_effort", "verbosity"],
     "supports_xhigh_reasoning": true
   },
-  "Cerebras-GLM-4.6": {
+  "Cerebras-GLM-4.7": {
     "type": "cerebras",
-    "name": "zai-glm-4.6",
+    "name": "zai-glm-4.7",
     "custom_endpoint": {
       "url": "https://api.cerebras.ai/v1",
       "api_key": "$CEREBRAS_API_KEY"

{code_puppy-0.0.336.dist-info → code_puppy-0.0.338.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.336
+Version: 0.0.338
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -34,6 +34,7 @@ Requires-Dist: rich>=13.4.2
 Requires-Dist: ripgrep==14.1.0
 Requires-Dist: ruff>=0.11.11
 Requires-Dist: tenacity>=8.2.0
+Requires-Dist: termflow-md>=0.1.6
 Requires-Dist: uvicorn>=0.30.0
 Description-Content-Type: text/markdown
 
@@ -106,12 +107,7 @@ uvx code-puppy -i
 # Install UV if you don't have it
 curl -LsSf https://astral.sh/uv/install.sh | sh
 
-# Set UV to always use managed Python (one-time setup)
-echo 'export UV_MANAGED_PYTHON=1' >> ~/.zshrc  # or ~/.bashrc
-source ~/.zshrc  # or ~/.bashrc
-
-# Install and run code-puppy
-uvx code-puppy -i
+uvx code-puppy
 ```
 
 #### Windows
@@ -122,73 +118,15 @@ On Windows, we recommend installing code-puppy as a global tool for the best exp
 # Install UV if you don't have it (run in PowerShell as Admin)
 powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
 
-# Install code-puppy as a global tool
-uv tool install code-puppy
-
-# Run code-puppy
-code-puppy -i
-```
-
-**Why `uv tool install` on Windows?** Running with `uvx` creates an extra process layer that can interfere with keyboard signal handling (Ctrl+C, Ctrl+X). Installing as a tool runs code-puppy directly for reliable cancellation.
-
-#### Upgrading
-
-```bash
-# Upgrade code-puppy to the latest version
-uv tool upgrade code-puppy
-
-# Or upgrade all installed tools
-uv tool upgrade --all
-```
-
-UV will automatically download the latest compatible Python version (3.11+) if your system doesn't have one.
-
-### pip (Alternative)
-
-```bash
-pip install code-puppy
+uvx code-puppy
 ```
 
-*Note: pip installation requires your system Python to be 3.11 or newer.*
-
-### Permanent Python Management
-
-To make UV always use managed Python versions (recommended):
-
-```bash
-# Set environment variable permanently
-echo 'export UV_MANAGED_PYTHON=1' >> ~/.zshrc  # or ~/.bashrc
-source ~/.zshrc  # or ~/.bashrc
-
-# Now all UV commands will prefer managed Python installations
-uvx code-puppy  # No need for --managed-python flag anymore
-```
+## Changelog (By Kittylog!)
 
-### Verifying Python Version
-
-```bash
-# Check which Python UV will use
-uv python find
-
-# Or check the current project's Python
-uv run python --version
-```
+[📋 View the full changelog on Kittylog](https://kittylog.app/c/mpfaffenberger/code_puppy)
 
 ## Usage
 
-### Custom Commands
-Create markdown files in `.claude/commands/`, `.github/prompts/`, or `.agents/commands/` to define custom slash commands. The filename becomes the command name and the content runs as a prompt.
-
-```bash
-# Create a custom command
-echo "# Code Review
-
-Please review this code for security issues." > .claude/commands/review.md
-
-# Use it in Code Puppy
-/review with focus on authentication
-```
-
 ### Adding Models from models.dev 🆕
 
 While there are several models configured right out of the box from providers like Synthetic, Cerebras, OpenAI, Google, and Anthropic, Code Puppy integrates with [models.dev](https://models.dev) to let you browse and add models from **65+ providers** with a single command:
@@ -256,6 +194,18 @@ The following environment variables control DBOS behavior:
 - `DBOS_SYSTEM_DATABASE_URL`: Database URL used by DBOS. Can point to a local SQLite file or a Postgres instance. Example: `postgresql://postgres:dbos@localhost:5432/postgres`. Default: `dbos_store.sqlite` file in the config directory.
 - `DBOS_APP_VERSION`: If set, Code Puppy uses it as the [DBOS application version](https://docs.dbos.dev/architecture#application-and-workflow-versions) and automatically tries to recover pending workflows for this version. Default: Code Puppy version + Unix timestamp in millisecond (disable automatic recovery).
 
+### Custom Commands
+Create markdown files in `.claude/commands/`, `.github/prompts/`, or `.agents/commands/` to define custom slash commands. The filename becomes the command name and the content runs as a prompt.
+
+```bash
+# Create a custom command
+echo "# Code Review
+
+Please review this code for security issues." > .claude/commands/review.md
+
+# Use it in Code Puppy
+/review with focus on authentication
+```
 
 ## Requirements
 
@@ -275,9 +225,6 @@ For examples and more information about agent rules, visit [https://agent.md](ht
 
 Use the `/mcp` command to manage MCP (list, start, stop, status, etc.)
 
-Watch this video for examples! https://www.youtube.com/watch?v=1t1zEetOqlo
-
-
 ## Round Robin Model Distribution
 
 Code Puppy supports **Round Robin model distribution** to help you overcome rate limits and distribute load across multiple AI models. This feature automatically cycles through configured models with each request, maximizing your API usage while staying within rate limits.

{code_puppy-0.0.336.dist-info → code_puppy-0.0.338.dist-info}/RECORD

@@ -2,17 +2,17 @@ code_puppy/__init__.py,sha256=xMPewo9RNHb3yfFNIk5WCbv2cvSPtJOCgK2-GqLbNnU,373
 code_puppy/__main__.py,sha256=pDVssJOWP8A83iFkxMLY9YteHYat0EyWDQqMkKHpWp4,203
 code_puppy/callbacks.py,sha256=hqTV--dNxG5vwWWm3MrEjmb8MZuHFFdmHePl23NXPHk,8621
 code_puppy/chatgpt_codex_client.py,sha256=Om0ANB_kpHubhCwNzF9ENf8RvKBqs0IYzBLl_SNw0Vk,9833
-code_puppy/claude_cache_client.py,sha256=hZr_YtXZSQvBoJFtRbbecKucYqJgoMopqUmm0IxFYGY,6071
-code_puppy/cli_runner.py,sha256=4iosJ_zXv9WcG4764yFW-VOLjE3B7Og9yclp6Q4kaSQ,33875
+code_puppy/claude_cache_client.py,sha256=QaucFONE0InS1GANCZwMFx-7sEptbZfjVzb_CgjvuUo,7949
+code_puppy/cli_runner.py,sha256=E7C2pCWof4JgNcCRgMlodeTs2DyWh0NaB7_a_nwafM0,33117
 code_puppy/config.py,sha256=RlnrLkyFXm7h2Htf8rQA7vqoAyzLPMrESle417uLmFw,52373
 code_puppy/error_logging.py,sha256=a80OILCUtJhexI6a9GM-r5LqIdjvSRzggfgPp2jv1X0,3297
 code_puppy/gemini_code_assist.py,sha256=KGS7sO5OLc83nDF3xxS-QiU6vxW9vcm6hmzilu79Ef8,13867
-code_puppy/http_utils.py,sha256=BV_bf0i5iPh7HC7T1vlsbz3hvlVwdIzwpS2pfBBKPRo,11823
+code_puppy/http_utils.py,sha256=H3N5Qz2B1CcsGUYOycGWAqoNMr2P1NCVluKX3aRwRqI,10358
 code_puppy/keymap.py,sha256=IvMkTlB_bIqOWpbTpmftkdyjhtD5todXuEIw1zCZ4u0,3584
 code_puppy/main.py,sha256=82r3vZy_XcyEsenLn82BnUusaoyL3Bpm_Th_jKgqecE,273
-code_puppy/model_factory.py,sha256=Djhp_ukLTMNi8UdZsodhIU6D2X4DmJXnjZy_bzfce3k,37517
+code_puppy/model_factory.py,sha256=BSGHZlwtF7jkYz2qFG9oJglG-NnfmbsQXbx4I6stXW0,38313
 code_puppy/model_utils.py,sha256=NU8W8NW5F7QS_PXHaLeh55Air1koUV7IVYFP7Rz3XpY,3615
-code_puppy/models.json,sha256=IPABdOrDw2OZJxa0XGBWSWmBRerV6_pIEmKVLRtUbAk,3105
+code_puppy/models.json,sha256=FMQdE_yvP_8y0xxt3K918UkFL9cZMYAqW1SfXcQkU_k,3105
 code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
 code_puppy/models_dev_parser.py,sha256=8ndmWrsSyKbXXpRZPXc0w6TfWMuCcgaHiMifmlaBaPc,20611
 code_puppy/pydantic_patches.py,sha256=YecAEeCOjSIwIBu2O5vEw72atMSL37cXGrbEuukI07o,4582
@@ -21,7 +21,7 @@ code_puppy/round_robin_model.py,sha256=kSawwPUiPgg0yg8r4AAVgvjzsWkptxpSORd75-HP7
 code_puppy/session_storage.py,sha256=T4hOsAl9z0yz2JZCptjJBOnN8fCmkLZx5eLy1hTdv6Q,9631
 code_puppy/status_display.py,sha256=qHzIQGAPEa2_-4gQSg7_rE1ihOosBq8WO73MWFNmmlo,8938
 code_puppy/summarization_agent.py,sha256=6Pu_Wp_rF-HAhoX9u2uXTabRVkOZUYwRoMP1lzNS4ew,4485
-code_puppy/terminal_utils.py,sha256=CxcNLfPwTDblI0AEtEwhfZ4DTfqqwHjM_A10QslaMBk,8220
+code_puppy/terminal_utils.py,sha256=TaS19x7EZqudlBUAQwLMzBMNxBHBNInvQQREXqRGtkM,12984
 code_puppy/uvx_detection.py,sha256=tP9X9Nvzow--KIqtqjgrHQkSxMJ3EevfoaeoB9VLY2o,7224
 code_puppy/version_checker.py,sha256=aq2Mwxl1CR9sEFBgrPt3OQOowLOBUp9VaQYWJhuUv8Q,1780
 code_puppy/agents/__init__.py,sha256=PtPB7Z5MSwmUKipgt_qxvIuGggcuVaYwNbnp1UP4tPc,518
@@ -40,7 +40,7 @@ code_puppy/agents/agent_qa_expert.py,sha256=5Ikb4U3SZQknUEfwlHZiyZXKqnffnOTQagr_
 code_puppy/agents/agent_qa_kitten.py,sha256=5PeFFSwCFlTUvP6h5bGntx0xv5NmRwBiw0HnMqY8nLI,9107
 code_puppy/agents/agent_security_auditor.py,sha256=SpiYNA0XAsIwBj7S2_EQPRslRUmF_-b89pIJyW7DYtY,12022
 code_puppy/agents/agent_typescript_reviewer.py,sha256=vsnpp98xg6cIoFAEJrRTUM_i4wLEWGm5nJxs6fhHobM,10275
-code_puppy/agents/base_agent.py,sha256=r_znuUZJMv97Lh8zeSdS_KJzVGe7X3rAgBk3NZpIO7I,82855
+code_puppy/agents/base_agent.py,sha256=FsjSw4i4YYVi9iyxviy6Y0aRGsm9ALvkOLbAfjcGAmc,83923
 code_puppy/agents/json_agent.py,sha256=lhopDJDoiSGHvD8A6t50hi9ZBoNRKgUywfxd0Po_Dzc,4886
 code_puppy/agents/prompt_reviewer.py,sha256=JJrJ0m5q0Puxl8vFsyhAbY9ftU9n6c6UxEVdNct1E-Q,5558
 code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
@@ -112,10 +112,10 @@ code_puppy/messaging/bus.py,sha256=TbdltJ0D5tqnaE4irq1fcXllDYm-mQ_SiX1IFm-S4sw,2
 code_puppy/messaging/commands.py,sha256=77CtKVNaF5KS3Xyzd0ccDAisZWQxL3weVEt3J-SfYxo,5464
 code_puppy/messaging/markdown_patches.py,sha256=dMIJozzJChuHa8QNMSEz_kC-dyt7kZiDLZ7rjthbcmg,1626
 code_puppy/messaging/message_queue.py,sha256=e-viZxacBoNSxRJnCJ4hU4vzsSI3oX_rN58RwhJKFfU,11825
-code_puppy/messaging/messages.py,sha256=vNenUTgeZLk2clH4-BLcj44vpzDMmAsOrbwn_msaCVw,16351
+code_puppy/messaging/messages.py,sha256=F7RwMHeQrIk-8kuSSBU76wBq1NGuLb2H5cJrSMTC3XM,16464
 code_puppy/messaging/queue_console.py,sha256=T0U_V1tdN6hd9DLokp-HCk0mhu8Ivpfajha368CBZrU,9983
 code_puppy/messaging/renderers.py,sha256=GHVtMnxE1pJ-yrcRjacY81JcjlHRz3UVHzp-ohN-CGE,12058
-code_puppy/messaging/rich_renderer.py,sha256=YMj5bdZSjufzFL6kNUuNhsoI_NfXUfvWBQ1FDWPw2Ho,37480
+code_puppy/messaging/rich_renderer.py,sha256=FiT1e5S8nNQte0E6CMFQ3KyTixadkgKSjp1hcZXtyOE,37892
 code_puppy/messaging/spinner/__init__.py,sha256=KpK5tJqq9YnN3wklqvdH0BQmuwYnT83Mp4tPfQa9RqI,1664
 code_puppy/messaging/spinner/console_spinner.py,sha256=YIReuWPD01YPy58FqWdMDWj2QhauTUxKo675Ub4-eDA,8451
 code_puppy/messaging/spinner/spinner_base.py,sha256=JiQDAhCfwrWUFunb8Xcj1caEl34JJY7Bcio7mDeckSc,2694
@@ -123,7 +123,7 @@ code_puppy/plugins/__init__.py,sha256=gWgrXWoFpl-3Mxz2DAvxKW6SkCWrOnw-hKsY9O7nHc
 code_puppy/plugins/oauth_puppy_html.py,sha256=Wpa-V_NlRiBAvo_OXHuR7wvOH_jSt8L9HSFGiab6xI0,13058
 code_puppy/plugins/antigravity_oauth/__init__.py,sha256=1miHihSqRNXO20Vh_Gn9M3Aa2szh0gtdSCaKKj9nq0Q,362
 code_puppy/plugins/antigravity_oauth/accounts.py,sha256=GQit2-K24bsopmTZyscFUq3M0cAEO5WutHWnipVdgz8,14304
-code_puppy/plugins/antigravity_oauth/antigravity_model.py,sha256=FgZtXHsyTIX0wcJB7ivcdFd5DpRLqDFO_idcvMuDKtc,25336
+code_puppy/plugins/antigravity_oauth/antigravity_model.py,sha256=g0_nXnMg288CvBE48CFgZ-iAqlYbtbi1dcB4Up6cYYc,26115
 code_puppy/plugins/antigravity_oauth/config.py,sha256=BoQgqf5I2XoHWnBBo9vhCIc_XwPj9Mbp0Z95ygWwt78,1362
 code_puppy/plugins/antigravity_oauth/constants.py,sha256=qsrA10JJvzNuY0OobvvwCQcoGpILBninllcUUMKkUrQ,4644
 code_puppy/plugins/antigravity_oauth/oauth.py,sha256=ZHXJtZP63l6brOpX1WdLfuUClIleA79-4y36YUJc6Wo,15137
@@ -145,7 +145,7 @@ code_puppy/plugins/claude_code_oauth/__init__.py,sha256=mCcOU-wM7LNCDjr-w-WLPzom
 code_puppy/plugins/claude_code_oauth/config.py,sha256=DjGySCkvjSGZds6DYErLMAi3TItt8iSLGvyJN98nSEM,2013
 code_puppy/plugins/claude_code_oauth/register_callbacks.py,sha256=g8sl-i7jIOF6OFALeaLqTF3mS4tD8GR_FCzvPjVw2js,10165
 code_puppy/plugins/claude_code_oauth/test_plugin.py,sha256=yQy4EeZl4bjrcog1d8BjknoDTRK75mRXXvkSQJYSSEM,9286
-code_puppy/plugins/claude_code_oauth/utils.py,sha256=wDaOU21zB3y6PWkuMXwE4mFjQuffyDae-vXysPTS-w8,13438
+code_puppy/plugins/claude_code_oauth/utils.py,sha256=TVgz5aFd2GFPHSiG9NnOYiw-y6KRkWwt_SZxmMpwMIY,17243
 code_puppy/plugins/customizable_commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_puppy/plugins/customizable_commands/register_callbacks.py,sha256=zVMfIzr--hVn0IOXxIicbmgj2s-HZUgtrOc0NCDOnDw,5183
 code_puppy/plugins/example_custom_command/README.md,sha256=5c5Zkm7CW6BDSfe3WoLU7GW6t5mjjYAbu9-_pu-b3p4,8244
@@ -159,7 +159,7 @@ code_puppy/plugins/shell_safety/register_callbacks.py,sha256=W3v664RR48Fdbbbltf_
 code_puppy/prompts/codex_system_prompt.md,sha256=hEFTCziroLqZmqNle5kG34A8kvTteOWezCiVrAEKhE0,24400
 code_puppy/tools/__init__.py,sha256=BVTZ85jLHgDANwOnUSOz3UDlp8VQDq4DoGF23BRlyWw,6032
 code_puppy/tools/agent_tools.py,sha256=snBI6FlFtR03CbYKXwu53R48c_fRSuDIwcNdVUruLcA,21020
-code_puppy/tools/command_runner.py,sha256=4RlgPWWE2Mk35t69QJWR4Md4etMGLR2rFSZAKrNohU4,44917
+code_puppy/tools/command_runner.py,sha256=3qXVnVTaBPia6y2D29As47_TRKgpyCj82yMFK-8UUYc,44954
 code_puppy/tools/common.py,sha256=IboS6sbwN4a3FzHdfsZJtEFiyDUCszevI6LpH14ydEk,40561
 code_puppy/tools/file_modifications.py,sha256=vz9n7R0AGDSdLUArZr_55yJLkyI30M8zreAppxIx02M,29380
 code_puppy/tools/file_operations.py,sha256=CqhpuBnOFOcQCIYXOujskxq2VMLWYJhibYrH0YcPSfA,35692
@@ -174,10 +174,10 @@ code_puppy/tools/browser/browser_scripts.py,sha256=sNb8eLEyzhasy5hV4B9OjM8yIVMLV
 code_puppy/tools/browser/browser_workflows.py,sha256=nitW42vCf0ieTX1gLabozTugNQ8phtoFzZbiAhw1V90,6491
 code_puppy/tools/browser/camoufox_manager.py,sha256=RZjGOEftE5sI_tsercUyXFSZI2wpStXf-q0PdYh2G3I,8680
 code_puppy/tools/browser/vqa_agent.py,sha256=DBn9HKloILqJSTSdNZzH_PYWT0B2h9VwmY6akFQI_uU,2913
-code_puppy-0.0.336.data/data/code_puppy/models.json,sha256=IPABdOrDw2OZJxa0XGBWSWmBRerV6_pIEmKVLRtUbAk,3105
-code_puppy-0.0.336.data/data/code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
-code_puppy-0.0.336.dist-info/METADATA,sha256=K0YyE2O8F9-nMuMdbs2rAovJHJmtQox98_r4beIjGPA,28854
-code_puppy-0.0.336.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-code_puppy-0.0.336.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
-code_puppy-0.0.336.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.336.dist-info/RECORD,,
+code_puppy-0.0.338.data/data/code_puppy/models.json,sha256=FMQdE_yvP_8y0xxt3K918UkFL9cZMYAqW1SfXcQkU_k,3105
+code_puppy-0.0.338.data/data/code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
+code_puppy-0.0.338.dist-info/METADATA,sha256=kNsGvoJiQpXWHOgGVtrwjkyYvFo8sVRj6xtxXRr83Lw,27520
+code_puppy-0.0.338.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+code_puppy-0.0.338.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
+code_puppy-0.0.338.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.338.dist-info/RECORD,,