code-puppy 0.0.908__tar.gz → 0.0.910__tar.gz

{code_puppy-0.0.908 → code_puppy-0.0.910}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy
-Version: 0.0.908
+Version: 0.0.910
 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.908 → code_puppy-0.0.910}/code_puppy/agents/_builder.py

@@ -11,6 +11,7 @@ hook; see :func:`code_puppy.callbacks.on_wrap_pydantic_agent`.
 
 from __future__ import annotations
 
+import os
 import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Tuple
@@ -142,6 +143,23 @@ def _truncate_agents_md(content: str, source: str, max_chars: int) -> str:
     return content[:max_chars] + notice
 
 
+def _same_file(candidate: Path, other: Optional[Path]) -> bool:
+    """True when ``candidate`` is the very file ``other`` names.
+
+    Run from the home directory, ``.code_puppy/AGENTS.md`` *is* the global
+    ``~/.code_puppy/AGENTS.md``; loading it again as project rules puts the
+    same text into the system prompt twice. Compared by filesystem identity,
+    so symlinks and path aliases count as the same file, while a distinct
+    project file with identical text still loads.
+    """
+    if other is None:
+        return False
+    try:
+        return os.path.samefile(candidate, other)
+    except OSError:
+        return False
+
+
 def load_puppy_rules() -> Optional[str]:
     """Load AGENT(S).md from global config dir and/or the current project dir.
 
@@ -163,12 +181,14 @@ def load_puppy_rules() -> Optional[str]:
     max_chars = get_agents_md_max_chars()
 
     global_rules: Optional[str] = None
+    global_file: Optional[Path] = None
     for name in _AGENT_RULE_FILES:
         candidate = Path(CONFIG_DIR) / name
         if candidate.exists():
             text = _read_rules_text(candidate)
             if text is None:
                 continue
+            global_file = candidate
             global_rules = _truncate_agents_md(
                 text,
                 source=f"global {_friendly_path(candidate)}",
@@ -183,7 +203,7 @@ def load_puppy_rules() -> Optional[str]:
     if code_puppy_dir.is_dir():
         for name in _AGENT_RULE_FILES:
             candidate = code_puppy_dir / name
-            if candidate.exists():
+            if candidate.exists() and not _same_file(candidate, global_file):
                 text = _read_rules_text(candidate)
                 if text is None:
                     continue
@@ -198,7 +218,7 @@ def load_puppy_rules() -> Optional[str]:
     if project_rules is None:
         for name in _AGENT_RULE_FILES:
             candidate = Path(name)
-            if candidate.exists():
+            if candidate.exists() and not _same_file(candidate, global_file):
                 text = _read_rules_text(candidate)
                 if text is None:
                     continue

{code_puppy-0.0.908 → code_puppy-0.0.910}/code_puppy/claude_cache_client.py

@@ -24,6 +24,12 @@ from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 import httpx2
 
 from .claude_oauth_transport import ClaudeOAuthTransport
+from .claude_thinking_display import (
+    _OFF_THINKING_TYPES,
+    _THINKING_OMITTED_WHEN_OFF,
+    _enforce_thinking_display_summary,
+    _thinking_endpoint,
+)
 from .http_retry import describe_exception
 
 logger = logging.getLogger(__name__)
@@ -51,41 +57,6 @@ CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI for C
 THINKING_DISPLAY_UPDATES_BETA = "thinking-display-updates-2026-08-18"
 
 
-def _model_requires_thinking_summary(model_name):
-    if not model_name:
-        return False
-    from code_puppy.model_utils import should_use_anthropic_thinking_summary
-
-    return should_use_anthropic_thinking_summary(model_name)
-
-
-def _model_supports_thinking_updates(model_name):
-    if not model_name:
-        return False
-    from code_puppy.model_utils import should_use_anthropic_thinking_updates
-
-    return should_use_anthropic_thinking_updates(model_name)
-
-
-def _enforce_thinking_display_summary(payload):
-    if not isinstance(payload, dict):
-        return False
-    if not _model_requires_thinking_summary(payload.get("model")):
-        return False
-    thinking = payload.get("thinking")
-    if not isinstance(thinking, dict):
-        return False
-    display = thinking.get("display")
-    if display == "summarized":
-        return False
-    if display == "updates" and _model_supports_thinking_updates(payload.get("model")):
-        # Fable 5.1 legitimately asked for progress updates; don't clobber
-        # it back to summarized (which would drown status lines in reasoning).
-        return False
-    thinking["display"] = "summarized"
-    return True
-
-
 class ClaudeCacheAsyncClient(ClaudeOAuthTransport, httpx2.AsyncClient):
     """Async HTTP client with Claude Code OAuth transformations.
 
@@ -196,14 +167,16 @@ class ClaudeCacheAsyncClient(ClaudeOAuthTransport, httpx2.AsyncClient):
         return json.dumps(data).encode("utf-8")
 
     @staticmethod
-    def _enforce_thinking_display_summary_body(body: bytes) -> bytes | None:
-        """Return a rewritten body when summarized thinking is required."""
+    def _enforce_thinking_display_summary_body(
+        body: bytes, endpoint=None
+    ) -> bytes | None:
+        """Return a rewritten body when the thinking shape needs normalizing."""
         try:
             payload = json.loads(body.decode("utf-8"))
         except Exception:
             return None
         if not isinstance(payload, dict) or not _enforce_thinking_display_summary(
-            payload
+            payload, endpoint
         ):
             return None
         return json.dumps(payload).encode("utf-8")
@@ -318,7 +291,7 @@ class ClaudeCacheAsyncClient(ClaudeOAuthTransport, httpx2.AsyncClient):
                         body_modified = True
                 if body_bytes:
                     summarized_body = self._enforce_thinking_display_summary_body(
-                        body_bytes
+                        body_bytes, _thinking_endpoint(url)
                     )
                     if summarized_body is not None:
                         body_bytes = summarized_body
@@ -354,6 +327,10 @@ class ClaudeCacheAsyncClient(ClaudeOAuthTransport, httpx2.AsyncClient):
             except Exception as exc:
                 logger.debug("Error in Claude Code transformations: %s", exc)
         response = await self._send_with_retries(request, *args, **kwargs)
+        if is_messages_endpoint:
+            request, response = await self._retry_without_thinking_after_400(
+                request, response, *args, **kwargs
+            )
         try:
             if (
                 oauth_request
@@ -389,9 +366,14 @@ class ClaudeCacheAsyncClient(ClaudeOAuthTransport, httpx2.AsyncClient):
                         retry_request.extensions["claude_oauth_refresh_attempted"] = (
                             True
                         )
-                        return await self._send_with_retries(
+                        retried = await self._send_with_retries(
                             retry_request, *args, **kwargs
                         )
+                        if is_messages_endpoint:
+                            _, retried = await self._retry_without_thinking_after_400(
+                                retry_request, retried, *args, **kwargs
+                            )
+                        return retried
                     else:
                         logger.warning(
                             "Token recovery failed, returning original error"
@@ -400,6 +382,61 @@ class ClaudeCacheAsyncClient(ClaudeOAuthTransport, httpx2.AsyncClient):
             logger.debug("Error during token refresh attempt: %s", exc)
         return response
 
+    async def _retry_without_thinking_after_400(
+        self,
+        request: httpx2.Request,
+        response: httpx2.Response,
+        *args: Any,
+        **kwargs: Any,
+    ) -> tuple[httpx2.Request, httpx2.Response]:
+        """Resend once without ``thinking`` when the API refuses the off-switch.
+
+        Which "thinking off" shape a model accepts differs per model and
+        changes over time, so ask the API instead of keeping a list: a 400
+        that names ``thinking`` on a request that only asked for thinking
+        off is retried with the key omitted, which every probed model
+        accepts. The (endpoint, model) is remembered only once that retry
+        succeeds. Returns the request actually in effect so OAuth recovery
+        resends the corrected body, not the refused one.
+        """
+        if response.status_code != 400:
+            return request, response
+        try:
+            body = self._extract_body_bytes(request)
+            payload = json.loads(body) if body else None
+            thinking = payload.get("thinking") if isinstance(payload, dict) else None
+            if not isinstance(thinking, dict) or (
+                thinking.get("type") not in _OFF_THINKING_TYPES
+            ):
+                return request, response
+            error = json.loads(await response.aread()).get("error") or {}
+            if "thinking" not in str(error.get("message", "")).lower():
+                return request, response
+            del payload["thinking"]
+            headers = {
+                k: v
+                for k, v in request.headers.items()
+                if k.lower() != "content-length"
+            }
+            retry_request = self.build_request(
+                method=request.method,
+                url=request.url,
+                headers=headers,
+                content=json.dumps(payload).encode("utf-8"),
+                extensions=dict(request.extensions),
+            )
+        except Exception as exc:
+            logger.debug("Could not retry without thinking: %s", exc)
+            return request, response
+        logger.info("Model refused thinking off-switch; retrying without thinking")
+        await response.aclose()
+        retried = await self._send_with_retries(retry_request, *args, **kwargs)
+        if retried.status_code < 400:
+            _THINKING_OMITTED_WHEN_OFF.add(
+                (_thinking_endpoint(request.url), payload.get("model"))
+            )
+        return retry_request, retried
+
     async def _send_with_retries(
         self, request: httpx2.Request, *args: Any, **kwargs: Any
     ) -> httpx2.Response:

code_puppy-0.0.910/code_puppy/claude_thinking_display.py

@@ -0,0 +1,71 @@
+"""Thinking ``display`` / off-switch normalization for Anthropic request bodies.
+
+The API only accepts ``display`` while thinking runs (``adaptive`` /
+``enabled``). Which "thinking off" shape a model accepts differs per model, so
+nothing here names a model: the client learns it from the provider's own 400.
+
+Called by: claude_cache_client :: ClaudeCacheAsyncClient.send()
+"""
+
+
+def _model_requires_thinking_summary(model_name):
+    if not model_name:
+        return False
+    from code_puppy.model_utils import should_use_anthropic_thinking_summary
+
+    return should_use_anthropic_thinking_summary(model_name)
+
+
+def _model_supports_thinking_updates(model_name):
+    if not model_name:
+        return False
+    from code_puppy.model_utils import should_use_anthropic_thinking_updates
+
+    return should_use_anthropic_thinking_updates(model_name)
+
+
+# The API only accepts ``thinking.display`` while thinking actually runs.
+_DISPLAY_THINKING_TYPES = frozenset({"adaptive", "enabled"})
+_OFF_THINKING_TYPES = frozenset({"disabled", "between_tools"})
+
+# (endpoint, model) pairs whose API refused an "off" thinking shape and then
+# accepted the request without it (see ``_retry_without_thinking_after_400``).
+# Never listed by name: each family accepts a different off-switch, and the
+# same model ID can sit behind providers that disagree, hence the endpoint.
+_THINKING_OMITTED_WHEN_OFF: set[tuple] = set()
+
+
+def _thinking_endpoint(url):
+    return (url.host, url.port, url.path)
+
+
+def _normalize_thinking_off(payload, thinking, endpoint):
+    modified = thinking.pop("display", None) is not None
+    if (
+        thinking.get("type") in _OFF_THINKING_TYPES
+        and (endpoint, payload.get("model")) in _THINKING_OMITTED_WHEN_OFF
+    ):
+        del payload["thinking"]
+        return True
+    return modified
+
+
+def _enforce_thinking_display_summary(payload, endpoint=None):
+    if not isinstance(payload, dict):
+        return False
+    thinking = payload.get("thinking")
+    if not isinstance(thinking, dict):
+        return False
+    if thinking.get("type") not in _DISPLAY_THINKING_TYPES:
+        return _normalize_thinking_off(payload, thinking, endpoint)
+    if not _model_requires_thinking_summary(payload.get("model")):
+        return False
+    display = thinking.get("display")
+    if display == "summarized":
+        return False
+    if display == "updates" and _model_supports_thinking_updates(payload.get("model")):
+        # Fable 5.1 legitimately asked for progress updates; don't clobber
+        # it back to summarized (which would drown status lines in reasoning).
+        return False
+    thinking["display"] = "summarized"
+    return True

{code_puppy-0.0.908 → code_puppy-0.0.910}/pyproject.toml

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