langchain-codex-plus 0.0.2__tar.gz → 0.0.3__tar.gz

{langchain_codex_plus-0.0.2 → langchain_codex_plus-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-codex-plus
-Version: 0.0.2
+Version: 0.0.3
 Summary: LangChain ChatModel for OpenAI Codex Plus / Pro (ChatGPT-account subscription protocol, not api.openai.com).
 Project-URL: Homepage, https://github.com/jasoncarreira/langchain-codex-plus
 Project-URL: Issues, https://github.com/jasoncarreira/langchain-codex-plus/issues

{langchain_codex_plus-0.0.2 → langchain_codex_plus-0.0.3}/langchain_codex_plus/codex_chat_model.py

@@ -552,13 +552,21 @@ class ChatCodexPlus(BaseChatModel):
             return
         body_bytes = response.read()
         err = parse_error_body(body_bytes)
-        # Re-raise with status code prepended so callers can pattern-
-        # match on it.
+        # Surface the rate-limit headers on errors too (esp. 429): fire
+        # the callback so the usage snapshot updates even on a refusal,
+        # and attach status_code + headers + parsed limits to the
+        # exception. Previously these were discarded — this method ran
+        # BEFORE _fire_rate_limit_callback on the success path, so a 429
+        # gave callers no reset timestamp to pause on.
+        rate_limits = self._fire_rate_limit_callback(response.headers)
         raise CodexResponseError(
             message=f"HTTP {response.status_code}: {err.message}",
             code=err.code,
             type=err.type,
             raw=err.raw,
+            status_code=response.status_code,
+            headers=dict(response.headers),
+            rate_limits=rate_limits,
         )
 
     def _consume_sync(
@@ -686,11 +694,17 @@ class ChatCodexPlus(BaseChatModel):
             return
         body_bytes = await response.aread()
         err = parse_error_body(body_bytes)
+        # See _raise_for_http_error: surface rate-limit headers on errors
+        # so a 429 carries its reset timestamp instead of being opaque.
+        rate_limits = self._fire_rate_limit_callback(response.headers)
         raise CodexResponseError(
             message=f"HTTP {response.status_code}: {err.message}",
             code=err.code,
             type=err.type,
             raw=err.raw,
+            status_code=response.status_code,
+            headers=dict(response.headers),
+            rate_limits=rate_limits,
         )
 
     async def _consume_async(

{langchain_codex_plus-0.0.2 → langchain_codex_plus-0.0.3}/langchain_codex_plus/codex_protocol.py

@@ -746,15 +746,31 @@ class CodexResponseError(RuntimeError):
         code: str | None = None,
         type: str | None = None,
         raw: Any = None,
+        status_code: int | None = None,
+        headers: dict[str, str] | None = None,
+        rate_limits: Any = None,
     ) -> None:
         super().__init__(message)
         self.message = message
         self.code = code
         self.type = type
         self.raw = raw
+        # HTTP envelope context — populated for non-2xx responses so
+        # callers can pattern-match on the status and, crucially, read
+        # the rate-limit headers on a 429 (the reset timestamp lives in
+        # ``x-codex-primary-reset-at`` / ``-reset-after-seconds``). These
+        # used to be discarded; a caller hitting a 429 had no way to know
+        # when the window would roll over. ``rate_limits`` is the parsed
+        # :class:`~langchain_codex_plus.rate_limits.CodexRateLimits` (or
+        # ``None`` when the response carried no ``x-codex-*`` headers).
+        self.status_code = status_code
+        self.headers = headers
+        self.rate_limits = rate_limits
 
     def __repr__(self) -> str:
         bits = [f"message={self.message!r}"]
+        if self.status_code is not None:
+            bits.append(f"status_code={self.status_code!r}")
         if self.code:
             bits.append(f"code={self.code!r}")
         if self.type:

{langchain_codex_plus-0.0.2 → langchain_codex_plus-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langchain-codex-plus"
-version = "0.0.2"
+version = "0.0.3"
 description = "LangChain ChatModel for OpenAI Codex Plus / Pro (ChatGPT-account subscription protocol, not api.openai.com)."
 readme = "README.md"
 requires-python = ">=3.11"

{langchain_codex_plus-0.0.2 → langchain_codex_plus-0.0.3}/tests/test_codex_chat_model.py

@@ -290,6 +290,50 @@ def test_generate_raises_on_oai_error_shape(auth_file):
     assert exc.value.type == "invalid_request_error"
 
 
+def test_generate_429_surfaces_rate_limit_headers(auth_file):
+    """A 429 must surface status_code + headers + parsed rate_limits on
+    the exception (so callers can pause until the real window reset) AND
+    fire the rate-limit callback even on the refusal. Previously the
+    headers were discarded — _raise_for_http_error ran before the
+    callback on the success path, so a 429 was opaque."""
+    transport = _CaptureTransport(
+        status_code=429,
+        body=b'{"detail":"Rate limit exceeded"}',
+        headers=_real_rl_headers(),
+    )
+    seen: list[CodexRateLimits] = []
+    llm = _make_llm(
+        auth_file, transport=transport, rate_limit_callback=seen.append
+    )
+    with pytest.raises(CodexResponseError) as exc:
+        llm.invoke([HumanMessage("hi")])
+    err = exc.value
+    assert err.status_code == 429
+    assert err.headers is not None
+    assert err.headers.get("x-codex-primary-reset-at") == "1779343790"
+    assert err.rate_limits is not None
+    assert err.rate_limits.primary is not None
+    assert err.rate_limits.primary.reset_at == 1779343790
+    # The callback fired on the 429 (usage snapshot updates on refusals).
+    assert len(seen) == 1
+    assert seen[0].primary.reset_at == 1779343790
+
+
+def test_generate_429_without_codex_headers_still_sets_status(auth_file):
+    """A 429 with no ``x-codex-*`` headers still carries status_code (and
+    rate_limits is None) — callers fall back to a backoff."""
+    transport = _CaptureTransport(
+        status_code=429,
+        body=b'{"detail":"Rate limit exceeded"}',
+        headers={"Content-Type": "application/json"},
+    )
+    llm = _make_llm(auth_file, transport=transport)
+    with pytest.raises(CodexResponseError) as exc:
+        llm.invoke([HumanMessage("hi")])
+    assert exc.value.status_code == 429
+    assert exc.value.rate_limits is None
+
+
 def test_generate_stop_argument_is_ignored_silently(auth_file, caplog):
     """Codex Responses API doesn't expose stop sequences. We log at
     DEBUG and proceed — silent drop in production logs."""

{langchain_codex_plus-0.0.2 → langchain_codex_plus-0.0.3}/uv.lock

@@ -253,7 +253,7 @@ wheels = [
 
 [[package]]
 name = "langchain-codex-plus"
-version = "0.0.1"
+version = "0.0.3"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },