code-puppy 0.0.485__tar.gz → 0.0.487__tar.gz

{code_puppy-0.0.485 → code_puppy-0.0.487}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.485
+Version: 0.0.487
 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.485 → code_puppy-0.0.487}/code_puppy/http_utils.py

@@ -5,7 +5,6 @@ This module provides functions for creating properly configured HTTP clients.
 """
 
 import asyncio
-import logging
 import os
 import socket
 import time
@@ -18,8 +17,6 @@ if TYPE_CHECKING:
     import requests
 from code_puppy.config import get_http2
 
-logger = logging.getLogger(__name__)
-
 
 @dataclass
 class ProxyConfig:
@@ -343,63 +340,6 @@ def create_reopenable_async_client(
             return httpx.AsyncClient(**base_kwargs)
 
 
-def disable_openai_sdk_retries(
-    http_client: httpx.AsyncClient,
-    **openai_kwargs: Any,
-) -> dict:
-    """When a RetryingAsyncClient is used as http_client for the OpenAI SDK,
-    disable the SDK's own retries to avoid multiplicative retry explosion.
-
-    The OpenAI SDK defaults to max_retries=2, and RetryingAsyncClient has 5.
-    Together with 3 streaming retries, a 429 can trigger up to
-    3 x 3 x 5 = 45 retries. Disabling SDK retries caps this at 3 x 5 = 15.
-
-    Returns provider kwargs. If the client is NOT a RetryingAsyncClient,
-    returns {"http_client": client} (+ any openai_kwargs as separate keys).
-    If it IS a RetryingAsyncClient, returns {"openai_client": AsyncOpenAI(...)}
-    with max_retries=0 and the provided openai_kwargs folded in.
-    Falls back to {"http_client": client} if AsyncOpenAI construction fails
-    (e.g. missing api_key).
-
-    Args:
-        http_client: The httpx client (possibly RetryingAsyncClient).
-        **openai_kwargs: Extra kwargs for AsyncOpenAI (api_key, base_url, etc).
-            Only used when creating an openai_client to bypass SDK retries.
-    """
-    if isinstance(http_client, RetryingAsyncClient):
-        try:
-            from openai import AsyncOpenAI
-
-            openai_client = AsyncOpenAI(
-                http_client=http_client,
-                max_retries=0,
-                **openai_kwargs,
-            )
-            return {"openai_client": openai_client}
-        except ImportError:
-            # openai package not installed; fall through
-            pass
-        except Exception as exc:
-            # Missing api_key (OpenAIError), wrong kwargs (TypeError),
-            # or other construction failures — fall back gracefully.
-            try:
-                from openai import OpenAIError as _OpenAIError
-
-                _warnable = (TypeError, ValueError, _OpenAIError)
-            except ImportError:
-                _warnable = (TypeError, ValueError)
-            if isinstance(exc, _warnable):
-                emit_warning(
-                    f"Could not disable OpenAI SDK retries ({exc}). "
-                    f"Falling back to http_client mode — multiplicative retries possible."
-                )
-            else:  # pragma: no cover
-                logger.debug("Unexpected error disabling OpenAI SDK retries: %s", exc)
-    result = {"http_client": http_client}
-    result.update(openai_kwargs)
-    return result
-
-
 def is_cert_bundle_available() -> bool:
     cert_path = get_cert_bundle_path()
     if cert_path is None:

{code_puppy-0.0.485 → code_puppy-0.0.487}/code_puppy/model_factory.py

@@ -25,12 +25,7 @@ from code_puppy.messaging import emit_warning
 from . import callbacks
 from .claude_cache_client import ClaudeCacheAsyncClient, patch_anthropic_client_messages
 from .config import EXTRA_MODELS_FILE, get_value, get_yolo_mode
-from .http_utils import (
-    create_async_client,
-    disable_openai_sdk_retries,
-    get_cert_bundle_path,
-    get_http2,
-)
+from .http_utils import create_async_client, get_cert_bundle_path, get_http2
 from .provider_identity import (
     make_anthropic_provider,
     make_openai_provider,
@@ -705,20 +700,11 @@ class ModelFactory:
                 verify=verify,
                 timeout=timeout if timeout is not None else 180,
             )
+            provider_args = {"base_url": url}
             if isinstance(client, httpx.AsyncClient):
-                # Disable OpenAI SDK retries when using our own
-                # RetryingAsyncClient to avoid multiplicative retry explosion
-                # (3 streaming x 3 SDK x 5 HTTP = 45 retries on 429)
-                openai_kwargs = {}
-                if url:
-                    openai_kwargs["base_url"] = url
-                if api_key:
-                    openai_kwargs["api_key"] = api_key
-                provider_args = disable_openai_sdk_retries(client, **openai_kwargs)
-            else:
-                provider_args = {"base_url": url}
-                if api_key:
-                    provider_args["api_key"] = api_key
+                provider_args["http_client"] = client
+            if api_key:
+                provider_args["api_key"] = api_key
             provider = make_openai_provider(provider_identity, **provider_args)
             model = OpenAIChatModel(model_name=model_config["name"], provider=provider)
             if model_name == "chatgpt-gpt-5-codex":
@@ -805,10 +791,10 @@ class ModelFactory:
                 model_name="cerebras",
                 timeout=timeout if timeout is not None else 180,
             )
-            # Disable OpenAI SDK retries when using our own
-            # RetryingAsyncClient to avoid multiplicative retry explosion
-            # (3 streaming x 3 SDK x 5 HTTP = 45 retries on 429)
-            provider_args = disable_openai_sdk_retries(client, api_key=api_key)
+            provider_args = dict(
+                api_key=api_key,
+                http_client=client,
+            )
             provider = ZaiCerebrasProvider(**provider_args)
 
             return OpenAIChatModel(model_name=model_config["name"], provider=provider)

{code_puppy-0.0.485 → code_puppy-0.0.487}/code_puppy/plugins/copilot_auth/register_callbacks.py

@@ -358,7 +358,7 @@ def _create_copilot_model(model_name: str, model_config: Dict, config: Dict) ->
     from pydantic_ai.models.openai import OpenAIChatModel
     from pydantic_ai.providers.openai import OpenAIProvider
 
-    from code_puppy.http_utils import create_async_client, disable_openai_sdk_retries
+    from code_puppy.http_utils import create_async_client
 
     # Discover token — match against the host stored in the model config
     host = model_config.get("copilot_host", "github.com")
@@ -414,14 +414,12 @@ def _create_copilot_model(model_name: str, model_config: Dict, config: Dict) ->
         if config_url:
             base_url = config_url
 
-    # Disable OpenAI SDK retries when using our own RetryingAsyncClient
-    # to avoid multiplicative retry explosion (3 streaming x 3 SDK x 5 HTTP = 45)
-    provider_kwargs = disable_openai_sdk_retries(
-        client,
+    # Use a placeholder API key — the actual token is injected by _CopilotAuth
+    provider = OpenAIProvider(
         api_key="copilot-session-managed",
         base_url=base_url,
+        http_client=client,
     )
-    provider = OpenAIProvider(**provider_kwargs)
 
     # Build a model profile that tells pydantic-ai how to handle thinking.
     # Claude models behind the Copilot API return thinking in a custom field

{code_puppy-0.0.485 → code_puppy-0.0.487}/code_puppy/tools/file_modifications.py

@@ -793,6 +793,21 @@ _REPLACEMENT_ITEM_SCHEMA = {
 InlineReplacement = Annotated[Dict[str, str], WithJsonSchema(_REPLACEMENT_ITEM_SCHEMA)]
 
 
+def _try_json_repair(v: Any) -> Any:
+    """Best-effort: turn a JSON-ish string into a real Python value.
+
+    Returns the parsed object on success, or the original ``v`` unchanged on
+    failure (or if ``v`` isn't a string in the first place). Used by both the
+    outer list coercion and the per-item validation in ``replace_in_file``.
+    """
+    if not isinstance(v, str):
+        return v
+    try:
+        return json.loads(json_repair.repair_json(v))
+    except Exception:
+        return v
+
+
 def _coerce_replacements_arg(v: Any) -> Any:
     """Coerce a stringified JSON array back into an actual list.
 
@@ -803,13 +818,7 @@ def _coerce_replacements_arg(v: Any) -> Any:
     the normal validator. Non-strings pass through untouched so regular list
     inputs keep their fast path.
     """
-    if isinstance(v, str):
-        try:
-            return json.loads(json_repair.repair_json(v))
-        except Exception:
-            # Fall through; let Pydantic raise its normal, informative error.
-            return v
-    return v
+    return _try_json_repair(v)
 
 
 # List type that tolerates JSON-string-encoded arrays coming from the wire.
@@ -836,32 +845,64 @@ def register_replace_in_file(agent):
         Replacements are applied sequentially. Prefer this over full file rewrites.
         """
         group_id = generate_group_id("replace_in_file", file_path)
-        # replacements arrive as plain dicts — pass them straight through
-        replacements_dict = [
-            {"old_str": r["old_str"], "new_str": r["new_str"]} for r in replacements
-        ]
-        result = _replace_in_file_helper(
-            context, file_path, replacements_dict, message_group=group_id
-        )
-        if "diff" in result:
-            del result["diff"]
-
-        # Trigger legacy edit_file callbacks for backward compatibility
-        payload = ReplacementsPayload(
-            file_path=file_path,
-            replacements=[
-                Replacement(old_str=r["old_str"], new_str=r["new_str"])
-                for r in replacements
-            ],
-        )
-        enhanced_results = on_edit_file(context, result, payload)
-        if enhanced_results:
-            for enhanced_result in enhanced_results:
-                if enhanced_result is not None:
-                    result = enhanced_result
-                    break
+        try:
+            # Validate replacements up front so a malformed payload from the
+            # model returns a clean error instead of bubbling a KeyError up
+            # through pydantic_ai and tearing down the whole agent run.
+            normalized: List[Dict[str, str]] = []
+            for idx, raw in enumerate(replacements):
+                # Per-item json_repair: some models stringify each replacement
+                # individually (e.g. ["{\"old_str\": ...}", ...]). Heal those
+                # before strict validation so we don't reject recoverable input.
+                r = _try_json_repair(raw)
+                if not isinstance(r, dict):
+                    return {
+                        "error": (
+                            f"replacements[{idx}] must be an object with "
+                            f"'old_str' and 'new_str' keys, got {type(raw).__name__}."
+                        )
+                    }
+                missing = [k for k in ("old_str", "new_str") if k not in r]
+                if missing:
+                    return {
+                        "error": (
+                            f"replacements[{idx}] is missing required key(s): "
+                            f"{', '.join(missing)}. Each replacement must include "
+                            f"both 'old_str' and 'new_str'."
+                        )
+                    }
+                normalized.append({"old_str": r["old_str"], "new_str": r["new_str"]})
 
-        return result
+            result = _replace_in_file_helper(
+                context, file_path, normalized, message_group=group_id
+            )
+            if "diff" in result:
+                del result["diff"]
+
+            # Trigger legacy edit_file callbacks for backward compatibility
+            payload = ReplacementsPayload(
+                file_path=file_path,
+                replacements=[
+                    Replacement(old_str=r["old_str"], new_str=r["new_str"])
+                    for r in normalized
+                ],
+            )
+            enhanced_results = on_edit_file(context, result, payload)
+            if enhanced_results:
+                for enhanced_result in enhanced_results:
+                    if enhanced_result is not None:
+                        result = enhanced_result
+                        break
+
+            return result
+        except Exception as exc:
+            # Last line of defense — never let this tool crash the agent run.
+            _log_error(
+                "Unhandled exception in replace_in_file",
+                exc,
+                message_group=group_id,
+            )
+            return {"error": f"replace_in_file failed: {exc}"}
 
 
 def register_delete_snippet(agent):

{code_puppy-0.0.485 → code_puppy-0.0.487}/pyproject.toml

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