code-puppy-core-plugins 0.0.69__tar.gz → 0.0.70__tar.gz

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.69
+Version: 0.0.70
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.15,>=3.11
+Requires-Dist: httpx2>=2.7
 Requires-Dist: httpx<1,>=0.24.1
 Requires-Dist: pydantic-ai-slim[anthropic,mcp,openai,typesafe]<3,>=2.51.0
 Description-Content-Type: text/markdown

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.70}/code_puppy_core_plugins/copilot_auth/reasoning_client.py

@@ -10,7 +10,7 @@ pydantic-ai's ``openai_chat_send_back_thinking_parts="field"`` mode preserves
 ``reasoning_opaque``.  The Copilot API returns **400 Bad Request** if
 ``reasoning_text`` is sent without the accompanying ``reasoning_opaque``.
 
-This module monkey-patches the httpx client to transparently:
+This module monkey-patches the httpx2 client to transparently:
 
 1. Capture ``reasoning_opaque`` (keyed by ``reasoning_text``) from responses
 2. Inject the matching ``reasoning_opaque`` into outgoing request messages
@@ -25,8 +25,8 @@ import json
 import logging
 from typing import Any, Dict
 
-import httpx
-from httpx import AsyncByteStream
+import httpx2
+from httpx2 import AsyncByteStream
 
 logger = logging.getLogger(__name__)
 
@@ -57,8 +57,8 @@ class _OpaqueCapturingStream(AsyncByteStream):
     lines, parses JSON, and pairs ``reasoning_text`` chunks with
     ``reasoning_opaque`` chunks for storage in *opaque_cache*.
 
-    Inherits from ``httpx.AsyncByteStream`` so that
-    ``httpx.Response.aclose()`` recognises us as an async stream and
+    Inherits from ``httpx2.AsyncByteStream`` so that
+    ``httpx2.Response.aclose()`` recognises us as an async stream and
     doesn't blow up with *"Attempted to call an async close on an sync
     stream"*.  Ask me how I know.
     """
@@ -188,9 +188,9 @@ def _capture_from_content(
 
 
 def _rebuild_request_body(
-    request: httpx.Request,
+    request: httpx2.Request,
     body: dict,
-    client: httpx.AsyncClient,
+    client: httpx2.AsyncClient,
 ) -> None:
     """Replace the request body in-place (mirrors ChatGPTCodexAsyncClient)."""
     new_body = json.dumps(body).encode("utf-8")
@@ -210,9 +210,9 @@ def _rebuild_request_body(
 
 
 def _inject_opaque_into_request(
-    request: httpx.Request,
+    request: httpx2.Request,
     opaque_cache: Dict[str, str],
-    client: httpx.AsyncClient,
+    client: httpx2.AsyncClient,
     thinking_field: str,
 ) -> None:
     """Add stored ``reasoning_opaque`` to assistant messages that need it.
@@ -288,8 +288,8 @@ def _inject_opaque_into_request(
 
 
 def _strip_all_reasoning_fields(
-    request: httpx.Request,
-    client: httpx.AsyncClient,
+    request: httpx2.Request,
+    client: httpx2.AsyncClient,
     thinking_field: str,
 ) -> bool:
     """Remove ALL reasoning fields from the request body.
@@ -340,17 +340,17 @@ def _strip_all_reasoning_fields(
 
 
 def patch_client_for_reasoning_opaque(
-    client: httpx.AsyncClient,
+    client: httpx2.AsyncClient,
     thinking_field: str = "reasoning_text",
 ) -> None:
     """Monkey-patch *client* to round-trip ``reasoning_opaque`` transparently.
 
     Call **after** creating the client but **before** handing it to
-    ``OpenAIProvider``.  Works with plain ``httpx.AsyncClient`` and the
+    ``OpenAIProvider``.  Works with plain ``httpx2.AsyncClient`` and the
     ``RetryingAsyncClient`` subclass returned by ``create_async_client``.
 
     Args:
-        client: The httpx async client to patch.
+        client: The httpx2 async client to patch.
         thinking_field: JSON field name that carries the thinking content
             (default ``"reasoning_text"`` — the Copilot Claude convention).
     """
@@ -358,8 +358,8 @@ def patch_client_for_reasoning_opaque(
     original_send = client.send
 
     async def _patched_send(
-        request: httpx.Request, *args: Any, **kwargs: Any
-    ) -> httpx.Response:
+        request: httpx2.Request, *args: Any, **kwargs: Any
+    ) -> httpx2.Response:
         # 1) Inject reasoning_opaque into outgoing POST bodies.
         #    Also strips orphaned reasoning_text with no cached opaque.
         if request.method == "POST":

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.70}/code_puppy_core_plugins/copilot_auth/register_callbacks.py

@@ -371,11 +371,11 @@ def _create_copilot_model(model_name: str, model_config: Dict, config: Dict) ->
     GPT-5.6 family, Codex, Grok, ...) are built as ``OpenAIResponsesModel``;
     everything else keeps using Chat Completions.
     """
-    import httpx
+    import httpx2
     from pydantic_ai.models.openai import OpenAIChatModel, OpenAIResponsesModel
     from pydantic_ai.providers.openai import OpenAIProvider
 
-    from code_puppy.http_utils import create_async_client
+    from code_puppy.httpx2_utils import create_async_client
 
     # Discover token — match against the host stored in the model config
     host = model_config.get("copilot_host", "github.com")
@@ -405,14 +405,14 @@ def _create_copilot_model(model_name: str, model_config: Dict, config: Dict) ->
         "Openai-Intent": COPILOT_AUTH_CONFIG["openai_intent"],
     }
 
-    class _CopilotAuth(httpx.Auth):
-        """httpx auth flow that refreshes the Copilot session token per-request."""
+    class _CopilotAuth(httpx2.Auth):
+        """httpx2 auth flow that refreshes the Copilot session token per-request."""
 
         def __init__(self, oauth_token: str, token_host: str):
             self._oauth_token = oauth_token
             self._host = token_host
 
-        def auth_flow(self, request: httpx.Request):
+        def auth_flow(self, request: httpx2.Request):
             token = get_valid_session_token(self._oauth_token, self._host)
             if token:
                 request.headers["Authorization"] = f"Bearer {token}"
@@ -447,7 +447,7 @@ def _create_copilot_model(model_name: str, model_config: Dict, config: Dict) ->
         from .reasoning_client import patch_client_for_reasoning_opaque
 
         # Field-mode so thinking persists across tool calls; the reasoning_opaque
-        # interceptor (patched onto the httpx client) re-injects the encrypted blob
+        # interceptor (patched onto the httpx2 client) re-injects the encrypted blob
         # into subsequent requests, preventing 400s.
         profile = OpenAIModelProfile(
             openai_chat_thinking_field="reasoning_text",

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.70}/code_puppy_core_plugins/copilot_auth/responses_stream.py

@@ -14,7 +14,7 @@ brand-new part: tool calls come through with empty ``arguments`` (the
 ``read_file ... Field required: file_path`` failure) and assistant text is
 split into one part per delta.
 
-This module wraps the httpx response byte-stream and rewrites each event so
+This module wraps the httpx2 response byte-stream and rewrites each event so
 every item keeps the first id seen for its ``output_index``.  Bytes that
 are not SSE ``data:`` JSON events pass through untouched.  The wrapper
 follows the ``_OpaqueCapturingStream`` pattern in ``reasoning_client``.
@@ -26,8 +26,8 @@ import json
 import logging
 from typing import Any, Dict
 
-import httpx
-from httpx import AsyncByteStream
+import httpx2
+from httpx2 import AsyncByteStream
 
 logger = logging.getLogger(__name__)
 
@@ -112,7 +112,7 @@ class _StableIdStream(AsyncByteStream):
     Buffers bytes, splits on newlines, rewrites ``data:`` JSON events via
     :func:`normalise_event_ids`, and re-emits them.  Everything else (event
     lines, blank separators, ``[DONE]``, unparseable payloads) is forwarded
-    verbatim.  Inherits ``httpx.AsyncByteStream`` so ``Response.aclose()``
+    verbatim.  Inherits ``httpx2.AsyncByteStream`` so ``Response.aclose()``
     treats it as an async stream.
     """
 
@@ -166,7 +166,7 @@ class _StableIdStream(AsyncByteStream):
         return b"data: " + json.dumps(event, ensure_ascii=False).encode("utf-8")
 
 
-def _is_responses_sse(request: httpx.Request, response: httpx.Response) -> bool:
+def _is_responses_sse(request: httpx2.Request, response: httpx2.Response) -> bool:
     if request.method != "POST" or not request.url.path.rstrip("/").endswith(
         "/responses"
     ):
@@ -175,7 +175,7 @@ def _is_responses_sse(request: httpx.Request, response: httpx.Response) -> bool:
     return "text/event-stream" in content_type.lower()
 
 
-def patch_client_for_stable_ids(client: httpx.AsyncClient) -> None:
+def patch_client_for_stable_ids(client: httpx2.AsyncClient) -> None:
     """Monkey-patch *client* so ``/responses`` SSE streams carry stable ids.
 
     Call after creating the client and before handing it to
@@ -186,8 +186,8 @@ def patch_client_for_stable_ids(client: httpx.AsyncClient) -> None:
     original_send = client.send
 
     async def _patched_send(
-        request: httpx.Request, *args: Any, **kwargs: Any
-    ) -> httpx.Response:
+        request: httpx2.Request, *args: Any, **kwargs: Any
+    ) -> httpx2.Response:
         response = await original_send(request, *args, **kwargs)
         if (
             response.status_code == 200

{code_puppy_core_plugins-0.0.69 → code_puppy_core_plugins-0.0.70}/pyproject.toml

@@ -4,12 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.69"
+version = "0.0.70"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
 dependencies = [
     "httpx>=0.24.1,<1",
+    "httpx2>=2.7",
     "pydantic-ai-slim[openai,anthropic,mcp,typesafe]>=2.51.0,<3",
 ]
 license = {text = "MIT"}