siwc-proxy 0.2.2__tar.gz → 0.2.3__tar.gz

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: siwc-proxy
-Version: 0.2.2
+Version: 0.2.3
 Summary: Local OpenAI-compatible API proxy for Sign in with ChatGPT token sharing
 Project-URL: Homepage, https://github.com/d-nyamkhuu/siwc-proxy
 Project-URL: Documentation, https://github.com/d-nyamkhuu/siwc-proxy/blob/main/docs/proxy.md
@@ -24,12 +24,11 @@ Classifier: Topic :: Internet :: Proxy Servers
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.12
 Requires-Dist: anyio>=4.4
-Requires-Dist: authlib<1.8,>=1.7.2
+Requires-Dist: authlib<1.9,>=1.8
 Requires-Dist: click>=8.1
 Requires-Dist: fastapi>=0.115
 Requires-Dist: filelock>=3.16
-Requires-Dist: httpx-sse>=0.4.3
-Requires-Dist: httpx<0.29,>=0.28
+Requires-Dist: httpx2<3,>=2.13
 Requires-Dist: itsdangerous>=2.2
 Requires-Dist: joserfc>=1.6
 Requires-Dist: platformdirs>=4.3

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/docs/proxy.md

@@ -224,34 +224,56 @@ These are always rejected: `n > 1`, `logprobs`, audio, and legacy
 
 Neither API keeps conversation state here: every Chat or Responses call is a new
 upstream request that carries the whole history. To keep long chats fast, turns
-need to reuse the prompt cache. ChatGPT sign-in keys that cache on a `session_id`
-request header and replaces any `prompt_cache_key` with a random value per
-request, so without a session no turn ever hits the cache.
+need to reuse the prompt cache. ChatGPT sign-in derives cache affinity from the
+`session-id` request header (as Codex sends it) and sets the prompt cache key
+from it, replacing any `prompt_cache_key` in the body. Without a session no turn
+ever hits the cache.
 
-The proxy sends a `session_id` on every inference request:
+The proxy sends a `session-id` on every inference request, and, like Codex, the
+same value as the body's `prompt_cache_key` (the API's official field, in case
+upstream starts honoring it):
 
-- The caller's own `session_id` header, if there is one, is forwarded as is.
+- The caller's own `session-id` header, if there is one, is used as is.
 - Otherwise, a `prompt_cache_key` from the body (Chat or Responses) names the
-  session; it is removed from the body, since upstream ignores it there.
+  session.
 - Otherwise, the session is derived from the model, `instructions` and the
   first input item (usually the system prompt). These stay the same as a
   conversation grows, so every turn lands in one session, and editing a later
   message keeps the cached prefix up to the edit. Conversations that start the
   same way share a session, which also shares the cache for that opening.
 
-Session values are HMACs under a key made at startup, so conversation text is
-never sent as an ID; a proxy restart starts new sessions. Usage reports hits in
-`prompt_tokens_details.cached_tokens` (Chat) or
-`input_tokens_details.cached_tokens` (Responses). Caching is best effort: in
-live tests, cached tokens grew with the history to about 80% of the prompt,
-but an occasional turn missed.
+Derived session values are HMACs under a key made at startup, so conversation
+text is never sent as an ID; a proxy restart starts new sessions. Usage reports
+hits in `prompt_tokens_details.cached_tokens` (Chat) or
+`input_tokens_details.cached_tokens` (Responses).
+
+**Caching is best effort, and cached tokens can go down.** The cache lives on
+several upstream machines, each holding only the prompts it served, and a
+session steers requests towards them without pinning a conversation to one. So
+each turn gets whatever the machine it lands on has:
+
+- the previous turn's prompt, rounded down to a multiple of 128 tokens, when it
+  lands where the last turn ran;
+- an earlier, shorter prefix when it lands on a machine that served an older turn,
+  so `cached` drops below the turn before;
+- nothing (`cached=0`) on a machine that has not seen the conversation, which is
+  common for the second and third turns.
+
+Prompts under 1024 tokens are never cached, so short side requests such as title
+generation always show `cached=0`. In live tests with 12-turn conversations of 4–8k
+tokens, 56–92% of input tokens after the first turn were cached, with 0–4 turns
+missing entirely. Sending Codex's other headers (`thread-id`, `x-client-request-id`)
+or replaying the `x-codex-turn-state` response header did not change this, and
+explicit `prompt_cache_breakpoint`s are rejected. What a client can control is the
+prefix: keep the system prompt (no timestamps), tools and their order,
+`reasoning_effort` and `response_format` identical between turns, and only append
+new messages.
 
 The access log shows each inference request's token counts and cache hit rate,
-the cached share of its input tokens, plus `cache_overall`, the rate across all
-requests since the proxy started:
+the cached share of its input tokens:
 
 ```text
-POST /v1/chat/completions 200 model=gpt-6.1-sol request_id=req_… 4834ms input=3611 cached=3456 (96%) output=11 cache_overall=48%
+POST /v1/chat/completions 200 model=gpt-6.1-sol request_id=req_… 4834ms input=3611 cached=3456 (96%) output=11
 ```
 
 ## Errors

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "siwc-proxy"
-version = "0.2.2"
+version = "0.2.3"
 description = "Local OpenAI-compatible API proxy for Sign in with ChatGPT token sharing"
 readme = "README.md"
 license = "MIT"
@@ -24,12 +24,11 @@ classifiers = [
 ]
 dependencies = [
     "anyio>=4.4",
-    "authlib>=1.7.2,<1.8",
+    "authlib>=1.8,<1.9",
     "click>=8.1",
     "fastapi>=0.115",
     "filelock>=3.16",
-    "httpx>=0.28,<0.29",
-    "httpx-sse>=0.4.3",
+    "httpx2>=2.13,<3",
     "itsdangerous>=2.2",
     "joserfc>=1.6",
     "platformdirs>=4.3",
@@ -48,7 +47,7 @@ siwc-proxy = "siwc_proxy.cli:main"
 
 [dependency-groups]
 dev = [
-    "openai>=2.54,<3",
+    "openai>=3,<4",
     "pytest>=8",
 ]
 
@@ -64,4 +63,4 @@ include = ["siwc_proxy", "tests", "docs", "README.md", "LICENSE"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-filterwarnings = ["ignore:Using `httpx` with `starlette.testclient`:UserWarning"]
+filterwarnings = ["error::authlib.deprecate.AuthlibDeprecationWarning"]

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/siwc_proxy/auth.py

@@ -11,7 +11,7 @@ import secrets
 import time
 
 import anyio
-import httpx
+import httpx2
 from authlib.integrations.base_client import OAuthError
 from authlib.integrations.httpx_client import AsyncOAuth2Client
 from authlib.integrations.starlette_client import OAuth
@@ -182,7 +182,7 @@ class ChatGPTAuth:
         except (JoseError, ValueError, KeyError, TypeError) as error:
             log.warning("Sign-in failed: invalid ID token (%s)", type(error).__name__)
             raise SignInError("OpenAI returned an identity token that could not be verified.") from None
-        except httpx.HTTPError as error:
+        except httpx2.HTTPError as error:
             log.warning("Sign-in failed: %s", type(error).__name__)
             raise SignInError("Could not reach OpenAI to finish sign-in. Start again.") from None
         claims = token.pop("userinfo", None)
@@ -262,9 +262,9 @@ class ChatGPTAuth:
         account = record.account
         try:
             metadata = await self.server_metadata()
-        except (httpx.HTTPError, ValueError) as error:
+        except (httpx2.HTTPError, ValueError) as error:
             log.warning("Refresh failed: discovery %s", type(error).__name__)
-            raise refresh_failed(isinstance(error, httpx.TimeoutException)) from None
+            raise refresh_failed(isinstance(error, httpx2.TimeoutException)) from None
         previous_scope, issued = account.scope, {}
 
         async def persist(token, refresh_token=None, access_token=None):
@@ -293,9 +293,9 @@ class ChatGPTAuth:
                                   "in again.", status=502, code="chatgpt_client_rejected") from None
             log.warning("Refresh failed: %s", error.error)
             raise refresh_failed() from None
-        except (httpx.HTTPError, ValueError, KeyError, TypeError) as error:
+        except (httpx2.HTTPError, ValueError, KeyError, TypeError) as error:
             log.warning("Refresh failed: %s", type(error).__name__)
-            raise refresh_failed(isinstance(error, httpx.TimeoutException)) from None
+            raise refresh_failed(isinstance(error, httpx2.TimeoutException)) from None
         log.info("Refreshed the ChatGPT access token.")
         if issued.get("id_token"):
             await self._check_identity(record, issued)
@@ -305,7 +305,7 @@ class ChatGPTAuth:
         try:
             claims = await self.remote(account.client_id).parse_id_token(
                 token, nonce=None, claims_options=self.claims_options(account.client_id), leeway=LEEWAY)
-        except (JoseError, ValueError, KeyError, TypeError, httpx.HTTPError) as error:
+        except (JoseError, ValueError, KeyError, TypeError, httpx2.HTTPError) as error:
             log.warning("Could not verify the refreshed ID token (%s); keeping tokens.", type(error).__name__)
             return
         if account.subject and claims["sub"] != account.subject:
@@ -351,7 +351,7 @@ class ChatGPTAuth:
                 if response.status_code < 500:
                     log.warning("OpenAI rejected token revocation (HTTP %s).", response.status_code)
                     return False
-            except httpx.TransportError as error:
+            except httpx2.TransportError as error:
                 log.warning("Revocation attempt %s failed: %s", attempt, type(error).__name__)
             if attempt < attempts:
                 await anyio.sleep(backoff(attempt))

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/siwc_proxy/cli.py

@@ -13,7 +13,7 @@ from urllib.parse import parse_qs, urlsplit
 
 import anyio
 import click
-import httpx
+import httpx2
 import uvicorn
 
 from .auth import ChatGPTAuth, SignInError
@@ -48,22 +48,22 @@ def make_settings(ctx, **overrides):
 
 def configure_logging(level):
     logging.basicConfig(level=level.upper(), format="%(asctime)s %(levelname)s %(name)s: %(message)s")
-    # httpx logs every outbound request at INFO; keep that for --log-level debug.
-    logging.getLogger("httpx").setLevel(logging.DEBUG if level == "debug" else logging.WARNING)
+    # httpx2 logs every outbound request at INFO; keep that for --log-level debug.
+    logging.getLogger("httpx2").setLevel(logging.DEBUG if level == "debug" else logging.WARNING)
     # Their debug output includes request headers and token responses.
     for name in ("authlib", "httpcore"):
         logging.getLogger(name).setLevel(logging.WARNING)
 
 
 def running_proxy(settings, api_key):
-    """An httpx client for a proxy already serving this data directory, or None.
+    """An httpx2 client for a proxy already serving this data directory, or None.
 
     The key is sent only after the server proves it knows it, so another program on the port never sees it.
     """
     from .server import healthz_proof
 
     challenge = secrets.token_hex(16)
-    client = httpx.Client(base_url=settings.origin, trust_env=False, timeout=10)
+    client = httpx2.Client(base_url=settings.origin, trust_env=False, timeout=10)
     try:
         response = client.get("/healthz", params={"challenge": challenge})
         proof = response.json().get("proof") if response.status_code == 200 else None
@@ -72,7 +72,7 @@ def running_proxy(settings, api_key):
             response = client.get("/auth/status")
             if response.status_code == 200:
                 return client
-    except (httpx.HTTPError, ValueError, AttributeError):
+    except (httpx2.HTTPError, ValueError, AttributeError):
         pass
     client.close()
     return None
@@ -226,7 +226,7 @@ def remote_login(settings, consent, port):
         url = anyio.run(lambda: auth.pasted_sign_in_url(session, consent))
     except CredentialFileError as error:
         fail(error)
-    except (httpx.HTTPError, ValueError) as error:
+    except (httpx2.HTTPError, ValueError) as error:
         raise click.ClickException(f"Could not reach OpenAI to start sign-in ({type(error).__name__}).") from None
     click.echo(f"Open this link in a browser on any computer and sign in:\n\n{click.style(url, fg='cyan', bold=True)}\n\n"
                f"The browser then goes to {settings.redirect_uri}?code=... and fails to load it. That is expected:\n"

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/siwc_proxy/responses.py

@@ -27,19 +27,24 @@ def system_to_developer(item):
     return item
 
 
-def cache_session(body, secret):
-    """Remove `prompt_cache_key` from an upstream body and return the `session_id` header to send instead.
+def cache_session(body, secret, supplied=None):
+    """Return the `session-id` header for an upstream body and set its `prompt_cache_key` to the same value.
 
-    ChatGPT sign-in keys its prompt cache on the `session_id` header and replaces `prompt_cache_key` with a
-    random value, so without a session every turn of a conversation misses the cache. A caller's own key is
-    used when given; otherwise the session comes from the model, instructions and first input item, which stay
-    the same as a conversation grows. Values are keyed hashes so conversation text never leaves as an ID.
+    ChatGPT sign-in derives prompt cache affinity from the `session-id` header and sets the prompt cache key
+    from it, so without a session every turn of a conversation misses the cache. Like Codex, the body carries
+    the same value as `prompt_cache_key`, the API's official field, in case upstream starts honoring it.
+    A caller's own `session-id` is used as is, and a caller's own key names the session; otherwise the session
+    comes from the model, instructions and first input item, which stay the same as a conversation grows.
+    Derived values are keyed hashes so conversation text never leaves as an ID.
     """
-    key = body.pop("prompt_cache_key", None)
-    if not isinstance(key, str) or not key:
-        first = body["input"][0] if isinstance(body.get("input"), list) and body["input"] else None
-        key = json.dumps([body.get("model"), body.get("instructions"), first], sort_keys=True)
-    return hmac.new(secret, key.encode(), hashlib.sha256).hexdigest()[:32]
+    if not supplied:
+        key = body.get("prompt_cache_key")
+        if not isinstance(key, str) or not key:
+            first = body["input"][0] if isinstance(body.get("input"), list) and body["input"] else None
+            key = json.dumps([body.get("model"), body.get("instructions"), first], sort_keys=True)
+        supplied = hmac.new(secret, key.encode(), hashlib.sha256).hexdigest()[:32]
+    body["prompt_cache_key"] = supplied
+    return supplied
 
 
 def normalize(body, *, strict=False):

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/siwc_proxy/server.py

@@ -10,7 +10,7 @@ from contextlib import asynccontextmanager
 from html import escape
 
 import anyio
-import httpx
+import httpx2
 from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse, Response, StreamingResponse
 from starlette.datastructures import Headers
@@ -54,12 +54,20 @@ def printable(text, limit=200):
     return "".join(c if c.isprintable() else "?" for c in text[:limit])
 
 
+def usage(counts):
+    """Token counts and the prompt cache hit rate (cached share of input tokens) for the access log."""
+    if not counts:
+        return ""
+    input_tokens, cached, output = counts
+    rate = f" ({cached / input_tokens:.0%})" if input_tokens else ""
+    return f" input={input_tokens} cached={cached}{rate} output={output}"
+
+
 class Boundary:
     """Host and bearer-key checks before any body is read, no-store responses, and access logs."""
 
     def __init__(self, app, settings, api_key):
         self.app, self.settings, self.key = app, settings, api_key.encode()
-        self.input_tokens = self.cached_tokens = 0  # Since startup, for the overall prompt cache hit rate.
 
     async def __call__(self, scope, receive, send):
         if scope["type"] != "http":
@@ -96,18 +104,7 @@ class Boundary:
             log.info("%s %s %s%s%s %.0fms%s", scope["method"], path, seen.get("status", "-"),
                      f" model={printable(model)}" if isinstance(model, str) else "",
                      f" request_id={printable(seen['request_id'])}" if seen.get("request_id") else "",
-                     (time.perf_counter() - started) * 1000, self.usage(scope.get("state", {}).get("usage")))
-
-    def usage(self, counts):
-        """Token counts and prompt cache hit rates (cached share of input tokens) for the access log."""
-        if not counts:
-            return ""
-        input_tokens, cached, output = counts
-        self.input_tokens += input_tokens
-        self.cached_tokens += cached
-        rate = f" ({cached / input_tokens:.0%})" if input_tokens else ""
-        overall = f" cache_overall={self.cached_tokens / self.input_tokens:.0%}" if self.input_tokens else ""
-        return f" input={input_tokens} cached={cached}{rate} output={output}{overall}"
+                     (time.perf_counter() - started) * 1000, usage(scope.get("state", {}).get("usage")))
 
 
 class Relayed(Exception):
@@ -160,7 +157,7 @@ def model_entry(model):
 
 
 def network_error(error):
-    if isinstance(error, httpx.TimeoutException):
+    if isinstance(error, httpx2.TimeoutException):
         return OpenAIError("OpenAI request timed out.", status=504, code="upstream_timeout")
     return OpenAIError("Could not reach OpenAI.", status=502, code="upstream_connection_error")
 
@@ -202,10 +199,10 @@ def create_app(settings=None, *, transport=None, api_key=None):
     async def lifespan(app):
         app.state.active = set()
         auth.serving, auth.signed_in = True, anyio.Event()
-        timeout = httpx.Timeout(30, read=settings.read_timeout)
+        timeout = httpx2.Timeout(30, read=settings.read_timeout)
         # The transport retries connection failures, before any request is sent.
-        upstream_transport = transport or httpx.AsyncHTTPTransport(retries=MAX_RETRIES)
-        async with httpx.AsyncClient(transport=upstream_transport, trust_env=False, follow_redirects=False,
+        upstream_transport = transport or httpx2.AsyncHTTPTransport(retries=MAX_RETRIES)
+        async with httpx2.AsyncClient(transport=upstream_transport, trust_env=False, follow_redirects=False,
                                      timeout=timeout) as client:
             app.state.upstream = client
             try:
@@ -238,7 +235,7 @@ def create_app(settings=None, *, transport=None, api_key=None):
     async def relayed(request, error):
         return error.response
 
-    @app.exception_handler(httpx.HTTPError)
+    @app.exception_handler(httpx2.HTTPError)
     async def http_error(request, error):
         return network_error(error).response()
 
@@ -268,9 +265,9 @@ def create_app(settings=None, *, transport=None, api_key=None):
         headers["Accept-Encoding"] = "identity"
         content = None
         if body is not None:
-            session = responses_api.cache_session(body, session_secret)
+            session = responses_api.cache_session(body, session_secret, request.headers.get("session-id"))
             headers.update({"Content-Type": "application/json", "Accept": "text/event-stream",
-                            "session_id": request.headers.get("session_id") or session})
+                            "session-id": session})
             content = json.dumps(body).encode()
         token, refreshed, attempt = await auth.access_token(), False, 0
         while True:
@@ -425,7 +422,7 @@ def create_app(settings=None, *, transport=None, api_key=None):
             request.state.usage = token_usage(result)
         except OpenAIError as error:
             return error.response(headers)
-        except httpx.HTTPError as error:
+        except httpx2.HTTPError as error:
             return network_error(error).response(headers)
         finally:
             await close(response)
@@ -468,7 +465,7 @@ def create_app(settings=None, *, transport=None, api_key=None):
                     yield b"data: [DONE]\n\n"
                 except OpenAIError as error:
                     yield encode_sse(error.payload)
-                except httpx.HTTPError as error:
+                except httpx2.HTTPError as error:
                     yield encode_sse(network_error(error).payload)
             return UpstreamStreamingResponse(sse(), headers=headers, media_type="text/event-stream",
                                              upstream=response, active=app.state.active)
@@ -478,7 +475,7 @@ def create_app(settings=None, *, transport=None, api_key=None):
             return JSONResponse(state.completion(), headers=headers)
         except OpenAIError as error:
             return error.response(headers)
-        except httpx.HTTPError as error:
+        except httpx2.HTTPError as error:
             return network_error(error).response(headers)
 
     return app

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/siwc_proxy/sse.py

@@ -3,7 +3,7 @@
 import json
 import re
 
-from httpx_sse import EventSource, SSEError
+from httpx2 import EventSource, SSEError
 
 from .errors import protocol_error
 
@@ -11,7 +11,8 @@ from .errors import protocol_error
 async def response_events(response):
     """Responses events from an upstream SSE body; events without data (keep-alives) are skipped."""
     try:
-        async for sse in EventSource(response).aiter_sse():
+        # No event size cap: terminal events repeat the whole answer, which may exceed httpx2's 1 MiB default.
+        async for sse in EventSource(response, max_event_size=None):
             if not sse.data:
                 continue
             try:

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/tests/support.py

@@ -7,7 +7,7 @@ import time
 from contextlib import contextmanager
 from urllib.parse import parse_qs
 
-import httpx
+import httpx2
 import uvicorn
 from fastapi.testclient import TestClient
 from joserfc import jwt
@@ -74,8 +74,8 @@ def parse_chunks(response):
             if line.startswith("data: ") and line != "data: [DONE]"]
 
 
-class Chunks(httpx.AsyncByteStream):
-    """A streamed body (unlike content=, which httpx pre-reads) that records being closed."""
+class Chunks(httpx2.AsyncByteStream):
+    """A streamed body (unlike content=, which httpx2 pre-reads) that records being closed."""
 
     def __init__(self, data, size=7):
         self.data, self.size, self.closed = data, size, False
@@ -122,30 +122,30 @@ class FakeOpenAI:
 
     def __init__(self):
         self.calls, self.token_calls, self.revocations = [], [], []
-        self.api = lambda request: httpx.Response(
+        self.api = lambda request: httpx2.Response(
             200, headers={"content-type": "text/event-stream", "x-request-id": "req-test"},
             stream=Chunks(sse(text_events())))
-        self.token = None  # optional override: callable(form) -> httpx.Response
-        self.revoke = lambda form: httpx.Response(200)
+        self.token = None  # optional override: callable(form) -> httpx2.Response
+        self.revoke = lambda form: httpx2.Response(200)
         self.codes = {}  # code -> (client_id, nonce, scope, sub)
         self.rotation = 0
         self.token_delay = 0
 
     @property
     def transport(self):
-        return httpx.MockTransport(self.handle)
+        return httpx2.MockTransport(self.handle)
 
     async def handle(self, request):
         self.calls.append(request)
         url = str(request.url.copy_with(query=None))
         if url == ISSUER + "/.well-known/openid-configuration":
-            return httpx.Response(200, json={
+            return httpx2.Response(200, json={
                 "issuer": ISSUER, "authorization_endpoint": ISSUER + "/oauth/authorize",
                 "token_endpoint": ISSUER + "/oauth/token", "jwks_uri": ISSUER + "/jwks",
                 "revocation_endpoint": ISSUER + "/oauth/revoke",
                 "id_token_signing_alg_values_supported": ["RS256"]})
         if url == ISSUER + "/jwks":
-            return httpx.Response(200, json=KeySet([SIGNING_KEY]).as_dict(private=False))
+            return httpx2.Response(200, json=KeySet([SIGNING_KEY]).as_dict(private=False))
         form = {k: v[0] for k, v in parse_qs(request.content.decode()).items()}
         if url == ISSUER + "/oauth/token":
             self.token_calls.append(form)
@@ -167,11 +167,11 @@ class FakeOpenAI:
         if form["grant_type"] == "authorization_code":
             client_id, nonce, scope, sub = self.codes[form["code"]]
             assert form["client_id"] == client_id
-            return httpx.Response(200, json={
+            return httpx2.Response(200, json={
                 "access_token": "new-access", "refresh_token": "new-refresh", "token_type": "Bearer",
                 "expires_in": 3600, "scope": scope, "id_token": id_token(client_id, sub, nonce)})
         self.rotation += 1
-        return httpx.Response(200, json={
+        return httpx2.Response(200, json={
             "access_token": f"refreshed-{self.rotation}", "refresh_token": f"rotated-{self.rotation}",
             "token_type": "Bearer", "expires_in": 3600})
 

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/tests/test_cli.py

@@ -8,7 +8,7 @@ import time
 from urllib.parse import parse_qs, urlsplit
 
 import click
-import httpx
+import httpx2
 import pytest
 from click.testing import CliRunner
 from fastapi.responses import JSONResponse
@@ -69,7 +69,7 @@ def test_standalone_login_serves_its_own_callback(tmp_path, monkeypatch):
 
     def browser(url, open_browser):
         def act():
-            with httpx.Client(trust_env=False, timeout=5) as client:
+            with httpx2.Client(trust_env=False, timeout=5) as client:
                 response = client.get(url, follow_redirects=False)
                 params = {k: v[0] for k, v in parse_qs(urlsplit(response.headers["location"]).query).items()}
                 fake.codes["c"] = ("oaiapp_cli", params["nonce"], "openid " + "chatgpt.tokens.use.direct", "sub-1")
@@ -122,12 +122,12 @@ def test_key_is_not_sent_to_an_impostor_on_the_port(tmp_path):
 def test_login_refuses_an_unexpected_link_from_the_proxy(tmp_path, monkeypatch):
     def proxy(request):
         if request.url.path == "/auth/status":
-            return httpx.Response(200, json={"state": "signed_out"})
-        return httpx.Response(200, json={"url": "file:///etc/passwd"})
+            return httpx2.Response(200, json={"state": "signed_out"})
+        return httpx2.Response(200, json={"url": "file:///etc/passwd"})
 
     opened = []
-    monkeypatch.setattr(cli, "running_proxy", lambda settings, key: httpx.Client(
-        base_url=settings.origin, transport=httpx.MockTransport(proxy)))
+    monkeypatch.setattr(cli, "running_proxy", lambda settings, key: httpx2.Client(
+        base_url=settings.origin, transport=httpx2.MockTransport(proxy)))
     monkeypatch.setattr(cli, "open_link", lambda url, browser: opened.append(url))
     result = CliRunner().invoke(cli.main, ["--data-dir", str(tmp_path), "login", "--no-browser"])
     assert result.exit_code == 1 and "unexpected sign-in link" in result.output and not opened

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/tests/test_compat_sdk.py

@@ -1,6 +1,6 @@
 """The stock openai SDK, used the way frameworks use it, against the proxy."""
 
-import httpx
+import httpx2
 import openai
 import pytest
 from openai import AsyncOpenAI, OpenAI
@@ -40,7 +40,7 @@ def realistic_events():
 
 def test_responses_streaming_and_helper(sdk):
     sdk, fake = sdk
-    fake.api = lambda r: httpx.Response(200, headers=SSE_TYPE, stream=Chunks(sse(realistic_events())))
+    fake.api = lambda r: httpx2.Response(200, headers=SSE_TYPE, stream=Chunks(sse(realistic_events())))
     events = list(sdk.responses.create(model="test-model", input="hi", stream=True))
     assert events[-1].type == "response.completed"
     with sdk.responses.stream(model="test-model", input="hi") as stream:
@@ -61,7 +61,7 @@ def test_chat_with_framework_defaults(sdk):
 
 def test_chat_stream_helper_accumulates_tool_arguments(sdk):
     sdk, fake = sdk
-    fake.api = lambda r: httpx.Response(200, headers=SSE_TYPE, stream=Chunks(sse(tool_events())))
+    fake.api = lambda r: httpx2.Response(200, headers=SSE_TYPE, stream=Chunks(sse(tool_events())))
     with sdk.chat.completions.stream(**BODY) as stream:
         list(stream)
         message = stream.get_final_completion().choices[0].message
@@ -72,7 +72,7 @@ def test_chat_stream_helper_accumulates_tool_arguments(sdk):
 @pytest.mark.parametrize("endpoint", ["chat", "responses"])
 def test_plan_limit_is_a_rate_limit_error(sdk, endpoint):
     sdk, fake = sdk
-    fake.api = lambda r: httpx.Response(200, headers=SSE_TYPE, stream=Chunks(sse([{"type": "response.failed", "response": terminal(
+    fake.api = lambda r: httpx2.Response(200, headers=SSE_TYPE, stream=Chunks(sse([{"type": "response.failed", "response": terminal(
         status="failed", error={"message": "Limit", "code": "subscription_sharing_usage_limit_exceeded"})}])))
     with pytest.raises(openai.RateLimitError) as caught:
         if endpoint == "chat":
@@ -84,7 +84,7 @@ def test_plan_limit_is_a_rate_limit_error(sdk, endpoint):
 
 def test_admission_detail_error(sdk):
     sdk, fake = sdk
-    fake.api = lambda r: httpx.Response(403, json={"detail": {"message": "Not eligible",
+    fake.api = lambda r: httpx2.Response(403, json={"detail": {"message": "Not eligible",
                                                               "code": "subscription_sharing_user_not_eligible"}})
     with pytest.raises(openai.PermissionDeniedError) as caught:
         sdk.chat.completions.create(**BODY)
@@ -96,7 +96,7 @@ def test_unknown_route_and_models(sdk):
     sdk, fake = sdk
     with pytest.raises(openai.NotFoundError):
         sdk.embeddings.create(model="x", input="hi")
-    fake.api = lambda r: httpx.Response(200, json={"models": [{"slug": "test-model", "visibility": "list"}]})
+    fake.api = lambda r: httpx2.Response(200, json={"models": [{"slug": "test-model", "visibility": "list"}]})
     assert [m.id for m in sdk.models.list()] == ["test-model"]
     assert sdk.models.retrieve("test-model").id == "test-model"
     with pytest.raises(openai.NotFoundError):
@@ -118,10 +118,10 @@ def test_async_sdk(directory, fake):
         app = create_app(Settings(data_dir=directory, api_key=KEY), transport=fake.transport)
         async with app.router.lifespan_context(app):
             async with AsyncOpenAI(api_key=KEY, base_url=BASE + "/v1", max_retries=0,
-                                   http_client=httpx.AsyncClient(transport=httpx.ASGITransport(app))) as sdk:
+                                   http_client=httpx2.AsyncClient(transport=httpx2.ASGITransport(app))) as sdk:
                 response = await sdk.responses.create(model="test-model", input="hi")
                 assert response.output_text == "Hi 世界"
-                fake.api = lambda r: httpx.Response(200, headers=SSE_TYPE, stream=Chunks(sse(text_events())))
+                fake.api = lambda r: httpx2.Response(200, headers=SSE_TYPE, stream=Chunks(sse(text_events())))
                 stream = await sdk.chat.completions.create(**BODY, stream=True)
                 text = "".join([c.choices[0].delta.content or "" async for c in stream if c.choices])
                 assert text == "Hi 世界"

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/tests/test_login.py

@@ -4,7 +4,7 @@ import time
 from urllib.parse import parse_qs, urlsplit
 
 import anyio
-import httpx
+import httpx2
 import pytest
 
 from siwc_proxy.auth import ChatGPTAuth
@@ -126,7 +126,7 @@ def test_callback_validation(tmp_path, fake, tamper):
                 value = id_token("oaiapp_issued", nonce=params["nonce"], **claims)
                 if tamper == "signature":
                     value = value[:-4] + ("AAAA" if not value.endswith("AAAA") else "BBBB")
-                return httpx.Response(200, json={"access_token": "a", "refresh_token": "r", "expires_in": 60,
+                return httpx2.Response(200, json={"access_token": "a", "refresh_token": "r", "expires_in": 60,
                                                  "id_token": value})
             fake.token = token
         page = client.get("/auth/callback", params=query)
@@ -181,7 +181,7 @@ def test_logout_revokes_and_keeps_registration(directory, fake):
 
 def test_logout_retries_server_errors_then_gives_up_locally(directory, fake, monkeypatch):
     monkeypatch.setattr("siwc_proxy.auth.backoff", lambda attempt: 0)
-    fake.revoke = lambda form: httpx.Response(503)
+    fake.revoke = lambda form: httpx2.Response(503)
     auth = ChatGPTAuth(Settings(data_dir=directory, api_key=KEY), Store(directory), transport=fake.transport)
     assert anyio.run(auth.logout) is False
     assert len(fake.revocations) == 4

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/tests/test_proxy.py

@@ -7,7 +7,7 @@ import socket
 import threading
 
 import anyio
-import httpx
+import httpx2
 import pytest
 from fastapi.testclient import TestClient
 
@@ -20,7 +20,7 @@ from support import (BASE, BODY, HEADERS, KEY, SSE_TYPE, TEXT_ITEM, Chunks, asse
 
 
 def streamed(events, **headers):
-    return lambda request: httpx.Response(200, headers={**SSE_TYPE, **headers},
+    return lambda request: httpx2.Response(200, headers={**SSE_TYPE, **headers},
                                           stream=Chunks(sse(events)))
 
 
@@ -73,7 +73,7 @@ def test_lenient_chat_reports_ignored_params(directory, fake):
 @pytest.mark.parametrize("streaming", [False, True])
 def test_interleaved_tools_have_dense_indexes_and_no_duplicates(directory, fake, streaming):
     stream = Chunks(sse(tool_events()), size=1)
-    fake.api = lambda r: httpx.Response(200, headers=SSE_TYPE, stream=stream)
+    fake.api = lambda r: httpx2.Response(200, headers=SSE_TYPE, stream=stream)
     with running(directory, fake) as (client, *_):
         response = client.post("/v1/chat/completions", json={**BODY, "stream": streaming})
         if streaming:
@@ -127,7 +127,7 @@ def test_incomplete_and_refusal(directory, fake, reason, finish, streaming):
 @pytest.mark.parametrize("streaming", [False, True])
 def test_stream_failures_never_report_success(directory, fake, bad, streaming):
     stream = Chunks(bad)
-    fake.api = lambda r: httpx.Response(200, headers={**SSE_TYPE, "x-request-id": "req-failed"}, stream=stream)
+    fake.api = lambda r: httpx2.Response(200, headers={**SSE_TYPE, "x-request-id": "req-failed"}, stream=stream)
     with running(directory, fake) as (client, fake, app):
         response = client.post("/v1/chat/completions", json={**BODY, "stream": streaming})
         assert response.headers["x-request-id"] == "req-failed"
@@ -161,7 +161,7 @@ def test_failed_responses_keep_their_meaning(directory, fake, code, status, endp
 
 
 def test_admission_usage_limit_is_not_retried_by_sdks(directory, fake):
-    fake.api = lambda r: httpx.Response(429, json={"error": {
+    fake.api = lambda r: httpx2.Response(429, json={"error": {
         "message": "Limit", "type": "rate_limit_error", "code": "subscription_sharing_usage_limit_exceeded"}})
     with running(directory, fake) as (client, *_):
         response = client.post("/v1/responses", json={"model": "m", "input": "Hi"})
@@ -180,7 +180,7 @@ def test_responses_drop_rejected_params_and_system_items(directory, fake):
         assert sent["input"][0] == {**system, "role": "developer"}
         assert sent["input"][1] == {"role": "system", "content": "x"}  # accepted as is
         assert "max_output_tokens" in sent and "temperature" not in sent
-        assert "prompt_cache_key" not in sent  # Replaced upstream; the session_id header carries it instead.
+        assert sent["prompt_cache_key"] == fake.calls[-1].headers["session-id"] != "k"  # Hashed into the session.
     with running(directory, fake, strict=True) as (client, *_):
         response = client.post("/v1/responses", json=body)
         assert response.status_code == 400 and response.json()["error"]["param"] == "temperature"
@@ -194,9 +194,11 @@ def test_turns_of_a_conversation_share_a_cache_session(directory, fake):
     edited = [system, {"role": "user", "content": "Edited"}] + turn2[2:]
     other = [{"role": "system", "content": "Different prompt"}, {"role": "user", "content": "Hi"}]
     with running(directory, fake) as (client, fake, _):
-        def session(path, body, **headers):
+        def session(path, body, headers=None):
             client.post(path, json=body, headers=headers)
-            return fake.calls[-1].headers["session_id"]
+            sent = fake.calls[-1]
+            assert json.loads(sent.content)["prompt_cache_key"] == sent.headers["session-id"]
+            return sent.headers["session-id"]
 
         chat = [session("/v1/chat/completions", {"model": "m", "messages": m}) for m in (turn1, turn2, edited, other)]
         assert chat[0] == chat[1] == chat[2] != chat[3]  # Edits after the first item keep the session.
@@ -208,10 +210,9 @@ def test_turns_of_a_conversation_share_a_cache_session(directory, fake):
         keyed = [session("/v1/chat/completions", {"model": "m", "messages": m, "prompt_cache_key": "conv-1"})
                  for m in (turn1, other)]
         assert keyed[0] == keyed[1] != chat[0]
-        assert "prompt_cache_key" not in json.loads(fake.calls[-1].content)
-        assert session("/v1/responses", {"model": "m", "input": turn1}, session_id="mine") == "mine"
+        assert session("/v1/responses", {"model": "m", "input": turn1}, {"session-id": "mine"}) == "mine"
         client.get("/v1/models")
-        assert "session_id" not in fake.calls[-1].headers
+        assert "session-id" not in fake.calls[-1].headers
 
 
 def test_multiline_sse_comments_crlf_and_bom(directory, fake):
@@ -219,7 +220,7 @@ def test_multiline_sse_comments_crlf_and_bom(directory, fake):
     split = event.index('"response":')
     raw = (": ping\r\nevent: response.completed\r\ndata: " + event[:split] + "\r\ndata: " + event[split:]
            + "\r\n\r\n").encode()
-    fake.api = lambda r: httpx.Response(200, headers=SSE_TYPE, stream=Chunks(raw, size=1))
+    fake.api = lambda r: httpx2.Response(200, headers=SSE_TYPE, stream=Chunks(raw, size=1))
     with running(directory, fake) as (client, *_):
         response = client.post("/v1/chat/completions", json=BODY)
         assert response.status_code == 200
@@ -238,7 +239,7 @@ def test_responses_normalized_and_aggregated(directory, fake):
         assert response.headers["x-siwc-ignored-params"] == "store"
         sent = json.loads(fake.calls[-1].content)
         assert sent == {"model": "test-model", "input": [{"role": "user", "content": "Hi"}],
-                        "store": False, "stream": True}
+                        "store": False, "stream": True, "prompt_cache_key": fake.calls[-1].headers["session-id"]}
         assert fake.calls[-1].url.query == b""  # only the models catalog takes query parameters
         assert fake.calls[-1].headers["openai-beta"] == "test=v1"
 
@@ -265,7 +266,7 @@ def empty_terminal_events():
 def test_relayed_stream_terminal_gets_output(directory, fake):
     events, item = empty_terminal_events()
     raw = sse(events).replace(b"\n", b"\r\n")
-    fake.api = lambda r: httpx.Response(200, stream=Chunks(gzip.compress(raw), size=5), headers={
+    fake.api = lambda r: httpx2.Response(200, stream=Chunks(gzip.compress(raw), size=5), headers={
         "content-encoding": "gzip", "content-length": "999", "content-type": "text/event-stream"})
     with running(directory, fake) as (client, *_):
         response = client.post("/v1/responses", json={"model": "m", "input": "Hi", "stream": True})
@@ -323,7 +324,7 @@ def test_responses_stream_is_relayed_unchanged(directory, fake):
     raw = sse(text_events()) + b'event: new.event\ndata: {"unknown":true}\n\n'
     compressed = gzip.compress(raw)
     stream = Chunks(compressed)
-    fake.api = lambda r: httpx.Response(200, stream=stream, headers={
+    fake.api = lambda r: httpx2.Response(200, stream=stream, headers={
         "content-encoding": "gzip", "content-type": "text/event-stream", "connection": "keep-alive, x-hop",
         "x-hop": "remove", "set-cookie": "a=1"})
     with running(directory, fake) as (client, *_):
@@ -338,7 +339,7 @@ def test_responses_stream_is_relayed_unchanged(directory, fake):
                                        ("/v1/responses", {"model": "m", "input": "Hi"}),
                                        ("/v1/responses", {"model": "m", "input": "Hi", "stream": True})])
 def test_stream_without_content_type(directory, fake, path, body):
-    fake.api = lambda r: httpx.Response(200, stream=Chunks(sse(text_events())))
+    fake.api = lambda r: httpx2.Response(200, stream=Chunks(sse(text_events())))
     with running(directory, fake) as (client, *_):
         response = client.post(path, json=body)
         assert response.status_code == 200
@@ -366,7 +367,7 @@ def test_responses_unsupported_features(directory, fake, body, param):
 @pytest.mark.parametrize("endpoint", ["chat/completions", "responses"])
 def test_upstream_errors_preserved(directory, fake, status, endpoint):
     body = b'{"error":{"message":"Denied","code":"permission_denied"}}'
-    fake.api = lambda r: httpx.Response(status, content=body, headers={
+    fake.api = lambda r: httpx2.Response(status, content=body, headers={
         "x-request-id": "req-denied", "retry-after": "2", "x-ratelimit-remaining-tokens": "100"})
     with running(directory, fake) as (client, fake, app):
         response = client.post("/v1/" + endpoint, json=BODY if endpoint.startswith("chat") else {"model": "m", "input": "x"})
@@ -383,7 +384,7 @@ def test_upstream_errors_preserved(directory, fake, status, endpoint):
     (b"<html>gateway</html>", "OpenAI returned HTTP 429.", None),
 ])
 def test_detail_bodies_become_openai_errors(directory, fake, body, message, code):
-    fake.api = lambda r: httpx.Response(429, content=body)
+    fake.api = lambda r: httpx2.Response(429, content=body)
     with running(directory, fake) as (client, *_):
         response = client.post("/v1/chat/completions", json=BODY)
         assert response.status_code == 429
@@ -392,7 +393,7 @@ def test_detail_bodies_become_openai_errors(directory, fake, body, message, code
 
 def test_retryable_admission_503_is_retried(directory, fake, monkeypatch):
     monkeypatch.setattr("siwc_proxy.server.backoff", lambda attempt: 0)
-    answers = iter([httpx.Response(503, json={"detail": {"code": "subscription_sharing_usage_unavailable"}},
+    answers = iter([httpx2.Response(503, json={"detail": {"code": "subscription_sharing_usage_unavailable"}},
                                    headers={"retry-after": "0"})])
     fake.api = lambda r: next(answers, None) or streamed(text_events())(r)
     with running(directory, fake) as (client, fake, _):
@@ -401,14 +402,14 @@ def test_retryable_admission_503_is_retried(directory, fake, monkeypatch):
 
 
 def test_other_503_is_not_retried(directory, fake):
-    fake.api = lambda r: httpx.Response(503, json={"error": {"message": "Down", "code": "overloaded"}})
+    fake.api = lambda r: httpx2.Response(503, json={"error": {"message": "Down", "code": "overloaded"}})
     with running(directory, fake) as (client, fake, _):
         assert client.post("/v1/chat/completions", json=BODY).status_code == 503
         assert len(fake.calls) == 1
 
 
-@pytest.mark.parametrize("error,status", [(httpx.ConnectError("secret network detail"), 502),
-                                          (httpx.ReadTimeout("secret timeout detail"), 504)])
+@pytest.mark.parametrize("error,status", [(httpx2.ConnectError("secret network detail"), 502),
+                                          (httpx2.ReadTimeout("secret timeout detail"), 504)])
 def test_network_errors_are_sanitized(directory, fake, error, status):
     def fail(request):
         raise error
@@ -424,10 +425,10 @@ def test_network_error_after_stream_start(directory, fake, streaming):
     class Broken(Chunks):
         async def __aiter__(self):
             yield sse(text_events()[:4])
-            raise httpx.ReadTimeout("private provider detail")
+            raise httpx2.ReadTimeout("private provider detail")
 
     broken = Broken(b"")
-    fake.api = lambda r: httpx.Response(200, headers=SSE_TYPE, stream=broken)
+    fake.api = lambda r: httpx2.Response(200, headers=SSE_TYPE, stream=broken)
     with running(directory, fake) as (client, *_):
         response = client.post("/v1/chat/completions", json={**BODY, "stream": streaming})
         if streaming:
@@ -482,7 +483,7 @@ def test_unknown_routes_are_openai_shaped(directory, fake):
 # Models
 
 def test_models_catalog_and_retrieve(directory, fake):
-    fake.api = lambda r: httpx.Response(200, json={"models": [
+    fake.api = lambda r: httpx2.Response(200, json={"models": [
         {"slug": "test-model", "display_name": "Test", "visibility": "list"},
         {"slug": "hidden", "visibility": "hidden"}]})
     with running(directory, fake) as (client, fake, _):
@@ -496,7 +497,7 @@ def test_models_catalog_and_retrieve(directory, fake):
 
 
 def test_models_query_is_forwarded(directory, fake):
-    fake.api = lambda r: httpx.Response(200, json={"models": [{"slug": "m", "visibility": "list"}]})
+    fake.api = lambda r: httpx2.Response(200, json={"models": [{"slug": "m", "visibility": "list"}]})
     with running(directory, fake) as (client, fake, _):
         assert client.get("/v1/models?client_version=1&x=a%20b").status_code == 200
         assert fake.calls[-1].url.query == b"client_version=1&x=a%20b"
@@ -504,7 +505,7 @@ def test_models_query_is_forwarded(directory, fake):
 
 
 def test_models_are_slimmed(directory, fake):
-    fake.api = lambda r: httpx.Response(200, json={"models": [{
+    fake.api = lambda r: httpx2.Response(200, json={"models": [{
         "slug": "big", "visibility": "list", "display_name": "Big", "context_window": 1000,
         "supported_reasoning_levels": [{"effort": "low", "description": "fast"}, {"effort": "high"}],
         "base_instructions": "x" * 50_000, "shell_type": "default"}]})
@@ -514,7 +515,7 @@ def test_models_are_slimmed(directory, fake):
             "context_window": 1000, "supported_reasoning_levels": ["low", "high"]}]
 
 def test_invalid_catalog(directory, fake):
-    fake.api = lambda r: httpx.Response(200, json={"models": "nope"})
+    fake.api = lambda r: httpx2.Response(200, json={"models": "nope"})
     with running(directory, fake) as (client, *_):
         assert client.get("/v1/models").status_code == 502
 
@@ -586,8 +587,8 @@ def test_access_log_reports_prompt_cache_hits(directory, fake, caplog, path, bod
         fake.api = streamed(text_events()[:-1])  # no terminal response, so no usage
         client.post(path, json=body)
     lines = [r.getMessage() for r in caplog.records if r.getMessage().startswith("POST /v1/")]
-    assert lines[0].endswith(" input=10 cached=2 (20%) output=4 cache_overall=20%")
-    assert lines[1].endswith(" input=10 cached=8 (80%) output=4 cache_overall=50%")
+    assert lines[0].endswith(" input=10 cached=2 (20%) output=4")
+    assert lines[1].endswith(" input=10 cached=8 (80%) output=4")
     assert "cached=" not in lines[2]
 
 
@@ -624,7 +625,7 @@ def test_corrupt_credentials(directory, fake):
 def test_real_http_streaming_and_disconnect_cleanup(directory, fake, endpoint, disconnect):
     gate, closed = threading.Event(), threading.Event()
 
-    class Delayed(httpx.AsyncByteStream):
+    class Delayed(httpx2.AsyncByteStream):
         async def __aiter__(self):
             yield sse(text_events()[:4])
             while not gate.is_set():
@@ -637,12 +638,12 @@ def test_real_http_streaming_and_disconnect_cleanup(directory, fake, endpoint, d
     sock = socket.socket()
     sock.bind(("127.0.0.1", 0))
     port = sock.getsockname()[1]
-    fake.api = lambda r: httpx.Response(200, stream=Delayed(), headers={"content-type": "text/event-stream"})
+    fake.api = lambda r: httpx2.Response(200, stream=Delayed(), headers={"content-type": "text/event-stream"})
     app = create_app(Settings(data_dir=directory, api_key=KEY, port=port), transport=fake.transport)
     body = {**BODY, "stream": True} if endpoint.startswith("chat") else {"model": "m", "input": "Hi", "stream": True}
     try:
         with live_server(app, sock):
-            with httpx.Client(timeout=2, trust_env=False) as client:
+            with httpx2.Client(timeout=2, trust_env=False) as client:
                 with client.stream("POST", f"http://127.0.0.1:{port}/v1/{endpoint}", headers=HEADERS,
                                    json=body) as response:
                     assert response.status_code == 200

{siwc_proxy-0.2.2 → siwc_proxy-0.2.3}/tests/test_tokens.py

@@ -7,7 +7,7 @@ import time
 from pathlib import Path
 
 import anyio
-import httpx
+import httpx2
 import pytest
 
 from siwc_proxy.auth import ChatGPTAuth
@@ -50,12 +50,12 @@ def test_valid_token_is_not_refreshed(directory, fake):
 
 def test_concurrent_requests_refresh_once(expired, fake):
     fake.token_delay = 0.1
-    fake.api = lambda r: httpx.Response(200, json={"object": "list", "data": []})
+    fake.api = lambda r: httpx2.Response(200, json={"object": "list", "data": []})
 
     async def exercise():
         app = create_app(Settings(data_dir=expired, api_key=KEY), transport=fake.transport)
         async with app.router.lifespan_context(app):
-            async with httpx.AsyncClient(transport=httpx.ASGITransport(app), base_url=BASE, headers=HEADERS) as client:
+            async with httpx2.AsyncClient(transport=httpx2.ASGITransport(app), base_url=BASE, headers=HEADERS) as client:
                 results = await asyncio_gather([client.get("/v1/models?n=" + str(i)) for i in range(8)])
         assert all(r.status_code == 200 for r in results)
         assert {c.headers["authorization"] for c in fake.calls if c.url.host == "api.openai.com"} == {
@@ -91,7 +91,7 @@ def test_separate_stores_share_the_file_lock(expired, fake):
 def test_processes_refresh_once(expired, tmp_path):
     log = tmp_path / "refreshes.log"
     script = textwrap.dedent(f"""
-        import sys, time, anyio, httpx
+        import sys, time, anyio, httpx2
         sys.path.insert(0, {str(Path(__file__).parent)!r})
         from support import FakeOpenAI
         from siwc_proxy.auth import ChatGPTAuth
@@ -104,7 +104,7 @@ def test_processes_refresh_once(expired, tmp_path):
                 f.write(form["refresh_token"] + "\\n")
             time.sleep(0.3)
             stamp = str(time.monotonic_ns())
-            return httpx.Response(200, json={{"access_token": "a-" + stamp, "refresh_token": "r-" + stamp,
+            return httpx2.Response(200, json={{"access_token": "a-" + stamp, "refresh_token": "r-" + stamp,
                                               "expires_in": 3600}})
         fake.token = token
         directory = {str(expired)!r}
@@ -120,10 +120,10 @@ def test_processes_refresh_once(expired, tmp_path):
 
 
 @pytest.mark.parametrize("answer", [
-    lambda form: httpx.Response(500, text="<html>oops</html>"),
-    lambda form: httpx.Response(503, json={"error": "temporarily_unavailable"}),
-    lambda form: httpx.Response(400, json={"error": "invalid_request"}),
-    lambda form: httpx.Response(200, json={"token_type": "Bearer"}),
+    lambda form: httpx2.Response(500, text="<html>oops</html>"),
+    lambda form: httpx2.Response(503, json={"error": "temporarily_unavailable"}),
+    lambda form: httpx2.Response(400, json={"error": "invalid_request"}),
+    lambda form: httpx2.Response(200, json={"token_type": "Bearer"}),
 ])
 def test_transient_failures_keep_credentials(expired, fake, answer):
     before = (expired / "credentials.json").read_bytes()
@@ -138,7 +138,7 @@ def test_network_failure_keeps_credentials(expired, fake):
     before = (expired / "credentials.json").read_bytes()
 
     def fail(form):
-        raise httpx.ReadTimeout("secret")
+        raise httpx2.ReadTimeout("secret")
     fake.token = fail
     with pytest.raises(OpenAIError) as caught:
         anyio.run(lambda: auth_for(expired, fake).access_token())
@@ -148,7 +148,7 @@ def test_network_failure_keeps_credentials(expired, fake):
 
 def test_invalid_client_keeps_credentials(expired, fake):
     before = (expired / "credentials.json").read_bytes()
-    fake.token = lambda form: httpx.Response(401, json={"error": "invalid_client"})
+    fake.token = lambda form: httpx2.Response(401, json={"error": "invalid_client"})
     with pytest.raises(OpenAIError) as caught:
         anyio.run(lambda: auth_for(expired, fake).access_token())
     assert caught.value.status == 502 and caught.value.code == "chatgpt_client_rejected"
@@ -158,7 +158,7 @@ def test_invalid_client_keeps_credentials(expired, fake):
 @pytest.mark.parametrize("code", ["invalid_grant", "refresh_token_reused", "refresh_token_expired",
                                   "refresh_token_invalidated", "invalid_refresh_token", "token_expired"])
 def test_terminal_refresh_errors_clear_tokens_but_keep_registration(expired, fake, code):
-    fake.token = lambda form: httpx.Response(400, json={"error": code})
+    fake.token = lambda form: httpx2.Response(400, json={"error": code})
     with pytest.raises(OpenAIError) as caught:
         anyio.run(lambda: auth_for(expired, fake).access_token())
     assert caught.value.status == 401 and caught.value.code == "chatgpt_login_required"
@@ -171,14 +171,14 @@ def test_terminal_refresh_errors_clear_tokens_but_keep_registration(expired, fak
 
 
 def test_unverifiable_id_token_after_rotation_keeps_new_tokens(expired, fake):
-    fake.token = lambda form: httpx.Response(200, json={
+    fake.token = lambda form: httpx2.Response(200, json={
         "access_token": "new-a", "refresh_token": "new-r", "expires_in": 3600, "id_token": "not.a.jwt"})
     assert anyio.run(lambda: auth_for(expired, fake).access_token()) == "new-a"
     assert saved(expired)["account"]["refresh_token"] == "new-r"
 
 
 def test_identity_change_on_refresh_clears_tokens(expired, fake):
-    fake.token = lambda form: httpx.Response(200, json={
+    fake.token = lambda form: httpx2.Response(200, json={
         "access_token": "new-a", "refresh_token": "new-r", "expires_in": 3600,
         "id_token": id_token("oaiapp_registered", sub="someone-else")})
     with pytest.raises(OpenAIError) as caught:
@@ -200,7 +200,7 @@ def test_earliest_refresh_at_is_respected(tmp_path, fake):
 
 def test_upstream_401_refreshes_and_retries_once(directory, fake):
     statuses = iter([401, 200])
-    fake.api = lambda r: httpx.Response(next(statuses), json={"object": "list", "data": []})
+    fake.api = lambda r: httpx2.Response(next(statuses), json={"object": "list", "data": []})
     with running(directory, fake) as (client, fake, _):
         assert client.get("/v1/models").status_code == 200
         api = [c for c in fake.calls if c.url.host == "api.openai.com"]
@@ -209,7 +209,7 @@ def test_upstream_401_refreshes_and_retries_once(directory, fake):
 
 
 def test_second_upstream_401_is_relayed(directory, fake):
-    fake.api = lambda r: httpx.Response(401, json={"error": {"message": "Bad token", "code": "invalid_token"}})
+    fake.api = lambda r: httpx2.Response(401, json={"error": {"message": "Bad token", "code": "invalid_token"}})
     with running(directory, fake) as (client, fake, _):
         response = client.post("/v1/chat/completions", json=BODY)
         assert response.status_code == 401 and response.json()["error"]["code"] == "invalid_token"