Code graph and memory for your coding agents, in one Rust program. For Claude Code, Codex, Cursor and any MCP client.
Rust agent-memoryai-agentsclaude-codecode-analysiscode-graphcode-intelligencecode-searchcodexcoding-agentscontext-engineeringcursordeveloper-toolsgraphragknowledge-graphlocal-firstmcpmcp-servermodel-context-protocolrusttree-sitter
fix: keep Retry-After when the service says the budget is spent
Rudy Celeklif48a3d28289f
diff --git a/crates/graphicle/tests/test_sdk_retry_after.py b/crates/graphicle/tests/test_sdk_retry_after.pynew file mode 100644index 0000000..5b0f993--- /dev/null+++ b/crates/graphicle/tests/test_sdk_retry_after.py@@ -0,0 +1,77 @@+"""A spent budget keeps Retry-After so the caller knows when to try again."""+import sys+import threading+from datetime import datetime, timedelta, timezone+from email.utils import format_datetime+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer+from pathlib import Path++import pytest++sys.path.insert(0, str(Path(__file__).resolve().parents[3] / "sdk" / "python"))+from graphicle_sdk import Client, GraphicleError+++class _Budget(BaseHTTPRequestHandler):+ def do_GET(self):+ body = b'{"error":"monthly request budget is spent"}'+ self.send_response(429)+ self.send_header("Content-Type", "application/json")+ self.send_header("Content-Length", str(len(body)))+ if self.path == "/seconds":+ self.send_header("Retry-After", "3600")+ elif self.path == "/date":+ when = datetime.now(timezone.utc) + timedelta(hours=2)+ self.send_header("Retry-After", format_datetime(when, usegmt=True))+ self.end_headers()+ self.wfile.write(body)++ def log_message(self, _format, *_args):+ return+++def _client():+ server = ThreadingHTTPServer(("127.0.0.1", 0), _Budget)+ thread = threading.Thread(target=server.serve_forever, daemon=True)+ thread.start()+ port = server.server_address[1]+ client = Client(f"http://127.0.0.1:{port}", "workspace", "test-capability", timeout=5)+ return server, client+++def test_retry_after_seconds_is_kept_on_the_error():+ server, client = _client()+ try:+ with pytest.raises(GraphicleError) as caught:+ client.request("GET", "/seconds")+ finally:+ server.shutdown()+ error = caught.value+ assert error.status == 429+ assert error.retry_after == 3600+ assert "3600" in str(error)+ assert "retry after" in str(error)+++def test_retry_after_http_date_is_seconds_from_now():+ server, client = _client()+ try:+ with pytest.raises(GraphicleError) as caught:+ client.request("GET", "/date")+ finally:+ server.shutdown()+ error = caught.value+ assert 7000 <= error.retry_after <= 7400+ assert "retry after" in str(error)+++def test_a_refusal_without_retry_after_stays_plain():+ server, client = _client()+ try:+ with pytest.raises(GraphicleError) as caught:+ client.request("GET", "/plain")+ finally:+ server.shutdown()+ error = caught.value+ assert error.retry_after is None+ assert "retry after" not in str(error)diff --git a/sdk/python/graphicle_sdk/client.py b/sdk/python/graphicle_sdk/client.pyindex e85634c..a6327ac 100644--- a/sdk/python/graphicle_sdk/client.py+++ b/sdk/python/graphicle_sdk/client.py@@ -48,7 +48,8 @@ including those this module does not wrap (``graph.query``, ``memory.export``, `drop arguments whose value is ``None``; ``command`` sends exactly what it is given.Errors: an HTTP error response raises :class:`GraphicleError` with ``status``, ``message`` (the-service's ``error`` text) and ``body``. HTTP 403 raises :class:`GraphiclePermissionError`, which is+service's ``error`` text), ``body`` and, when the response sent ``Retry-After``, ``retry_after``+in seconds. HTTP 403 raises :class:`GraphiclePermissionError`, which isalso a built-in :class:`PermissionError`. A failed or cancelled job raises :class:`GraphicleError`with ``status=None`` and the job record in ``job``; an unreachable service raises it with``status=None`` too. :meth:`Project.wait` raises :class:`TimeoutError`.@@ -60,6 +61,7 @@ forwarded), and ``repr()`` omits it. Only the Python standard library is used."""from __future__ import annotations+import email.utilsimport ipaddressimport jsonimport math@@ -69,7 +71,7 @@ import timeimport urllib.errorimport urllib.parseimport urllib.request-from datetime import date+from datetime import date, datetime, timezonefrom pathlib import Pathfrom typing import Any, Dict, Iterable, Iterator, List, Mapping, Optional, Sequence, Union@@ -120,18 +122,24 @@ class GraphicleError(Exception):``status`` is the HTTP status code, or ``None`` when there was no HTTP error response (theservice was unreachable, or a job failed or was cancelled). ``message`` is the service's errortext, ``body`` the parsed response body and ``job`` the job record for workflow failures.+ ``retry_after`` is seconds from a ``Retry-After`` header (a delay, or an HTTP-date counted+ from now), or ``None`` when the response did not send one."""def __init__(self, status: Optional[int], message: str, *, body: Any = None,- job: Optional[Dict[str, Any]] = None) -> None:+ job: Optional[Dict[str, Any]] = None, retry_after: Optional[int] = None) -> None:super().__init__(message)self.status = statusself.message = messageself.body = bodyself.job = job+ self.retry_after = retry_afterdef __str__(self) -> str:- return self.message if self.status is None else f"{self.message} (HTTP {self.status})"+ text = self.message if self.status is None else f"{self.message} (HTTP {self.status})"+ if self.retry_after is None:+ return text+ return f"{text}; retry after {self.retry_after} s"class GraphiclePermissionError(GraphicleError, PermissionError):@@ -144,7 +152,23 @@ class _NoRedirect(urllib.request.HTTPRedirectHandler):return None-def _error(status: int, raw: bytes) -> GraphicleError:+def _retry_after(headers: Any) -> Optional[int]:+ raw = headers.get("Retry-After") if headers is not None and hasattr(headers, "get") else None+ if not isinstance(raw, str):+ return None+ text = raw.strip()+ if text.isdigit():+ return int(text)+ parsed = email.utils.parsedate_to_datetime(text)+ if parsed is None:+ return None+ if parsed.tzinfo is None:+ parsed = parsed.replace(tzinfo=timezone.utc)+ delay = (parsed - datetime.now(timezone.utc)).total_seconds()+ return 0 if delay <= 0 else math.ceil(delay)+++def _error(status: int, raw: bytes, headers: Any = None) -> GraphicleError:text = raw.decode("utf-8", "replace").strip()try:body: Any = json.loads(text) if text else None@@ -155,7 +179,7 @@ def _error(status: int, raw: bytes) -> GraphicleError:else:message = text[:2000] or f"HTTP {status}"kind = GraphiclePermissionError if status == 403 else GraphicleError- return kind(status, message, body=body)+ return kind(status, message, body=body, retry_after=_retry_after(headers))def default_data_dir() -> Path:@@ -250,7 +274,7 @@ class Client:raw = b""finally:error.close()- raise _error(error.code, raw) from None+ raise _error(error.code, raw, error.headers) from Noneexcept (urllib.error.URLError, OSError) as error:reason = getattr(error, "reason", error)if isinstance(reason, TimeoutError):