memwal 0.1.11.dev6__tar.gz → 0.1.11.dev8__tar.gz

{memwal-0.1.11.dev6 → memwal-0.1.11.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.1.11.dev6
+Version: 0.1.11.dev8
 Summary: Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing
 Project-URL: Homepage, https://memory.walrus.xyz
 Project-URL: Documentation, https://memory.walrus.xyz

{memwal-0.1.11.dev6 → memwal-0.1.11.dev8}/memwal/__init__.py

@@ -128,4 +128,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.1.11.dev6"
+__version__ = "0.1.11.dev8"

{memwal-0.1.11.dev6 → memwal-0.1.11.dev8}/memwal/client.py

@@ -29,11 +29,13 @@ import asyncio
 import base64
 import json
 import logging
+import math
 import random
 import re
 import time
 import uuid
 from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
 from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TypeVar, Union
 from urllib.parse import ParseResult, urlencode, urlparse
 
@@ -199,18 +201,51 @@ def _positive_retry_ms(raw: object) -> Optional[int]:
         seconds = float(raw)  # type: ignore[arg-type]
     except (TypeError, ValueError):
         return None
-    if seconds <= 0 or seconds != seconds or seconds == float("inf"):
+    if seconds <= 0 or math.isnan(seconds) or math.isinf(seconds):
+        return None
+    try:
+        ms = seconds * 1000.0
+        if math.isinf(ms) or math.isnan(ms):
+            return None
+        return int(ms)
+    except (OverflowError, ValueError):
+        return None
+
+
+def _http_date_retry_ms(raw: object) -> Optional[int]:
+    if not isinstance(raw, str):
+        return None
+    try:
+        dt = parsedate_to_datetime(raw)
+        if dt is None:
+            return None
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        target_ts = dt.timestamp()
+        # HTTP-date is absolute wall-clock time, so we deliberately compare against
+        # time.time() rather than monotonic _now_ms().
+        now_ts = time.time()
+        diff = target_ts - now_ts
+        if diff <= 0 or math.isnan(diff) or math.isinf(diff):
+            return None
+        ms = diff * 1000.0
+        if math.isinf(ms) or math.isnan(ms):
+            return None
+        return int(ms)
+    except Exception:
         return None
-    return int(seconds * 1000)
 
 
 def _retry_after_ms(err: "_HttpStatusError") -> int:
-    """Retry-After seconds, else JSON ``retry_after_seconds``, in ms."""
+    """Retry-After seconds or HTTP-date, else JSON ``retry_after_seconds``, in ms."""
 
     if err.retry_after:
         header_ms = _positive_retry_ms(err.retry_after)
         if header_ms is not None:
             return header_ms
+        date_ms = _http_date_retry_ms(err.retry_after)
+        if date_ms is not None:
+            return date_ms
     if not err.body:
         return 0
     try:
@@ -463,6 +498,10 @@ class MemWal:
     ) -> RememberAcceptedResult:
         return await self.remember(text, namespace, idempotency_key)
 
+    def _poll_deadline_s(self, deadline_ms: int) -> float:
+        remaining_s = (deadline_ms - _now_ms()) / 1000.0
+        return max(0.001, min(60.0, remaining_s))
+
     async def wait_for_remember_job(
         self,
         job_id: str,
@@ -498,12 +537,25 @@ class MemWal:
             retry_after_ms = 0
 
             try:
-                data = await self._signed_request(
-                    "GET",
-                    f"/api/remember/{job_id}",
-                    {},
-                    accepted_statuses=(200, 404),
-                )
+                poll_timeout = self._poll_deadline_s(deadline_ms)
+                try:
+                    data = await self._signed_request(
+                        "GET",
+                        f"/api/remember/{job_id}",
+                        {},
+                        accepted_statuses=(200, 404),
+                        timeout=poll_timeout,
+                    )
+                except TypeError as err:
+                    if "unexpected keyword argument" in str(err) and "timeout" in str(err):
+                        data = await self._signed_request(
+                            "GET",
+                            f"/api/remember/{job_id}",
+                            {},
+                            accepted_statuses=(200, 404),
+                        )
+                    else:
+                        raise
             except _HttpStatusError as err:
                 if _is_transient_polling_status(err.status):
                     last_refusal = err.status
@@ -512,6 +564,11 @@ class MemWal:
                         retry_after_ms = _clamped_retry_after_ms(err, deadline_ms)
                     continue
                 raise
+            except httpx.TransportError:
+                # Network drops retry as status 0; continuing next loop iteration
+                # increments `attempt` so exponential backoff delay continues to grow.
+                last_refusal = 0
+                continue
 
             status_str = data.get("status")
             if status_str is None or status_str == "not_found":
@@ -632,7 +689,9 @@ class MemWal:
         return await self.remember_bulk_async(items)
 
     async def get_remember_bulk_status(
-        self, job_ids: Sequence[str]
+        self,
+        job_ids: Sequence[str],
+        timeout: Optional[float] = None,
     ) -> RememberBulkStatusResult:
         """Poll the bulk-status endpoint for a batch of job_ids.
 
@@ -644,6 +703,7 @@ class MemWal:
             "POST",
             "/api/remember/bulk/status",
             {"job_ids": list(job_ids)},
+            timeout=timeout,
         )
         return RememberBulkStatusResult(
             results=[
@@ -726,7 +786,14 @@ class MemWal:
             retry_after_ms = 0
 
             try:
-                batch = await self.get_remember_bulk_status(pending)
+                poll_timeout = self._poll_deadline_s(deadline_ms)
+                try:
+                    batch = await self.get_remember_bulk_status(pending, timeout=poll_timeout)
+                except TypeError as err:
+                    if "unexpected keyword argument" in str(err) and "timeout" in str(err):
+                        batch = await self.get_remember_bulk_status(pending)
+                    else:
+                        raise
             except _HttpStatusError as err:
                 if _is_transient_polling_status(err.status):
                     last_refusal = err.status
@@ -735,6 +802,11 @@ class MemWal:
                         retry_after_ms = _clamped_retry_after_ms(err, deadline_ms)
                     continue
                 raise
+            except httpx.TransportError:
+                # Network drops retry as status 0; continuing next loop iteration
+                # increments `attempt` so exponential backoff delay continues to grow.
+                last_refusal = 0
+                continue
             answered = True
 
             terminal_ids: Set[str] = {
@@ -757,6 +829,8 @@ class MemWal:
                     retry_after = f"{wait_ms / 1000:g}" if wait_ms else None
                     raise MemWalRateLimited(job_ids, retry_after) from err
                 # Any other probe failure is not evidence about the jobs.
+            except httpx.TransportError:
+                pass
             else:
                 answered = True
                 settled = {
@@ -1515,6 +1589,7 @@ class MemWal:
         body: Dict[str, Any],
         accepted_statuses: tuple = (200,),
         include_seal_session: bool = True,
+        timeout: Optional[float] = None,
     ) -> Dict[str, Any]:
         """Make a signed request to the server.
 
@@ -1575,6 +1650,7 @@ class MemWal:
             url=url,
             headers=headers,
             content=None if method_upper == "GET" else body_str,
+            timeout=timeout,
         )
 
         if response.status_code not in accepted_statuses:

{memwal-0.1.11.dev6 → memwal-0.1.11.dev8}/memwal/middleware.py

@@ -188,7 +188,7 @@ class _PendingSaves:
 
             try:
                 asyncio.run(_drain(list(self._tasks)))
-            except RuntimeError:
+            except (RuntimeError, ValueError):
                 logger.warning(
                     "Walrus Memory flush_sync() could not await %d pending "
                     "task(s) bound to a different event loop (mixing sync "
@@ -366,12 +366,32 @@ def with_memwal_langchain(
                     last_human_idx = i
                     break
 
-            guard_msg = SystemMessage(content=_UNTRUSTED_MEMORY_SYSTEM_INSTRUCTION)
             memory_msg = HumanMessage(content=memory_context)
             if last_human_idx > 0:
-                result[last_human_idx:last_human_idx] = [guard_msg, memory_msg]
+                result.insert(last_human_idx, memory_msg)
             else:
-                result[0:0] = [guard_msg, memory_msg]
+                result.insert(0, memory_msg)
+
+            if result and isinstance(result[0], SystemMessage):
+                existing_content = result[0].content
+                if isinstance(existing_content, list):
+                    new_content = list(existing_content) + [
+                        {"type": "text", "text": f"\n\n{_UNTRUSTED_MEMORY_SYSTEM_INSTRUCTION}"}
+                    ]
+                else:
+                    text_str = str(existing_content or "")
+                    new_content = f"{text_str}\n\n{_UNTRUSTED_MEMORY_SYSTEM_INSTRUCTION}".strip()
+                if hasattr(result[0], "model_copy"):
+                    result[0] = result[0].model_copy(update={"content": new_content})
+                else:
+                    result[0] = SystemMessage(
+                        content=new_content,
+                        additional_kwargs=getattr(result[0], "additional_kwargs", {}),
+                        id=getattr(result[0], "id", None),
+                        name=getattr(result[0], "name", None),
+                    )
+            else:
+                result.insert(0, SystemMessage(content=_UNTRUSTED_MEMORY_SYSTEM_INSTRUCTION))
 
             return result
         except Exception as e:
@@ -625,21 +645,36 @@ def _inject_openai_memory(
     messages: List[Dict[str, Any]],
     memory_context: str,
 ) -> List[Dict[str, Any]]:
-    """Insert a fixed system guard plus memory content in a user message."""
+    """Insert a fixed system guard at index 0 and memory content in a user message."""
+    result = [dict(m) if isinstance(m, dict) else m for m in messages]
     last_user_idx = -1
-    for i in range(len(messages) - 1, -1, -1):
-        if isinstance(messages[i], dict) and messages[i].get("role") == "user":
+    for i in range(len(result) - 1, -1, -1):
+        if isinstance(result[i], dict) and result[i].get("role") == "user":
             last_user_idx = i
             break
 
-    memory_messages: List[Dict[str, Any]] = [
-        {"role": "system", "content": _UNTRUSTED_MEMORY_SYSTEM_INSTRUCTION},
-        {"role": "user", "content": memory_context},
-    ]
-
+    memory_message = {"role": "user", "content": memory_context}
     if last_user_idx > 0:
-        messages[last_user_idx:last_user_idx] = memory_messages
+        result.insert(last_user_idx, memory_message)
+    else:
+        result.insert(0, memory_message)
+
+    if result and isinstance(result[0], dict) and result[0].get("role") == "system":
+        existing_content = result[0].get("content")
+        if isinstance(existing_content, list):
+            result[0] = {
+                **result[0],
+                "content": existing_content + [
+                    {"type": "text", "text": f"\n\n{_UNTRUSTED_MEMORY_SYSTEM_INSTRUCTION}"}
+                ],
+            }
+        else:
+            text_str = str(existing_content or "")
+            result[0] = {
+                **result[0],
+                "content": f"{text_str}\n\n{_UNTRUSTED_MEMORY_SYSTEM_INSTRUCTION}".strip(),
+            }
     else:
-        messages[0:0] = memory_messages
+        result.insert(0, {"role": "system", "content": _UNTRUSTED_MEMORY_SYSTEM_INSTRUCTION})
 
-    return messages
+    return result

{memwal-0.1.11.dev6 → memwal-0.1.11.dev8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memwal"
-version = "0.1.11.dev6"
+version = "0.1.11.dev8"
 description = "Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing"
 readme = "README.md"
 license = "MIT"

{memwal-0.1.11.dev6 → memwal-0.1.11.dev8}/tests/test_middleware.py

@@ -240,27 +240,53 @@ class TestFormatMemories:
 class TestInjectOpenAIMemory:
     """Tests for _inject_openai_memory."""
 
-    def test_inserts_before_last_user_message(self) -> None:
+    def test_folds_guard_into_system_message_and_inserts_memory_before_user_message(self) -> None:
         messages = [
             {"role": "system", "content": "You are helpful."},
             {"role": "user", "content": "question"},
         ]
         result = _inject_openai_memory(messages, "memory context")
-        # Should be: existing-system | fixed-guard | memory-user | user
+        # Should be: existing-system-with-guard | memory-user | user
+        assert len(result) == 3
         assert result[0]["role"] == "system"
-        assert result[1]["role"] == "system"
-        assert "untrusted data" in result[1]["content"]
-        assert result[2] == {"role": "user", "content": "memory context"}
-        assert result[3]["role"] == "user"
+        assert "You are helpful." in result[0]["content"]
+        assert "untrusted data" in result[0]["content"]
+        assert result[1] == {"role": "user", "content": "memory context"}
+        assert result[2]["role"] == "user"
+        assert result[2]["content"] == "question"
+
+    def test_multi_turn_never_injects_system_message_after_index_0(self) -> None:
+        messages = [
+            {"role": "system", "content": "You are helpful."},
+            {"role": "user", "content": "first"},
+            {"role": "assistant", "content": "reply"},
+            {"role": "user", "content": "second"},
+        ]
+        result = _inject_openai_memory(messages, "recalled fact")
+        # System message only at index 0
+        assert result[0]["role"] == "system"
+        assert "You are helpful." in result[0]["content"]
+        assert "untrusted data" in result[0]["content"]
+
+        # No system message after index 0
+        assert not any(m.get("role") == "system" for m in result[1:])
+
+        # Memory is injected as user message right before "second"
+        assert result[1] == {"role": "user", "content": "first"}
+        assert result[2] == {"role": "assistant", "content": "reply"}
+        assert result[3] == {"role": "user", "content": "recalled fact"}
+        assert result[4] == {"role": "user", "content": "second"}
 
     def test_inserts_at_start_when_only_user_message(self) -> None:
         messages = [{"role": "user", "content": "question"}]
         result = _inject_openai_memory(messages, "context")
-        # last_user_idx == 0, so prepend guard + memory-data messages
+        # When no system message exists, prepends guard system message at index 0
         assert result[0]["role"] == "system"
+        assert "untrusted data" in result[0]["content"]
         assert result[1]["role"] == "user"
         assert result[1]["content"] == "context"
         assert result[2]["role"] == "user"
+        assert result[2]["content"] == "question"
 
     def test_does_not_mutate_original(self) -> None:
         original = [{"role": "user", "content": "q"}]
@@ -335,6 +361,102 @@ class TestWithMemWalLangChain:
         assert "User loves coffee" in human_msgs[0].content
         assert "BEGIN_UNTRUSTED_WALRUS_MEMORY_" in human_msgs[0].content
 
+    @respx.mock
+    async def test_multi_turn_never_injects_system_message_after_index_0(self) -> None:
+        """In a multi-turn conversation, SystemMessage stays strictly at index 0."""
+        _mock_seal_session_prereqs()
+        from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+        from langchain_core.outputs import ChatGeneration, ChatResult
+
+        llm = self._make_llm()
+        captured: list = []
+
+        async def _capture_agenerate(messages_batch, *a, **kw):
+            captured.extend(messages_batch)
+            return ChatResult(
+                generations=[ChatGeneration(message=AIMessage(content="ok"))]
+            )
+
+        llm._agenerate = _capture_agenerate
+
+        respx.post(_RECALL_URL).mock(
+            return_value=_mock_recall([
+                {"blob_id": "b1", "text": "User loves coffee", "distance": 0.05}
+            ])
+        )
+        respx.post(_ANALYZE_URL).mock(return_value=_mock_analyze())
+
+        smart_llm = with_memwal_langchain(
+            llm, key=_KEY_HEX, account_id=_ACCOUNT_ID, server_url=_SERVER, auto_save=False
+        )
+        messages = [
+            SystemMessage(content="You are helpful."),
+            HumanMessage(content="I like coffee"),
+            AIMessage(content="Noted!"),
+            HumanMessage(content="What do I like?"),
+        ]
+        await smart_llm._agenerate([messages])
+
+        assert len(captured) == 1
+        injected = captured[0]
+        # SystemMessage strictly at index 0, with guard folded in
+        assert isinstance(injected[0], SystemMessage)
+        assert "You are helpful." in injected[0].content
+        assert "untrusted data" in injected[0].content
+
+        # No SystemMessage after index 0
+        assert not any(isinstance(m, SystemMessage) for m in injected[1:])
+
+        # The recalled memory is in a HumanMessage before the final query
+        assert isinstance(injected[3], HumanMessage)
+        assert "User loves coffee" in injected[3].content
+        assert isinstance(injected[4], HumanMessage)
+        assert injected[4].content == "What do I like?"
+
+    @respx.mock
+    async def test_multimodal_system_message_appends_block_and_preserves_metadata(self) -> None:
+        """A list-content SystemMessage appends a text block and retains its metadata."""
+        _mock_seal_session_prereqs()
+        from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+        from langchain_core.outputs import ChatGeneration, ChatResult
+
+        llm = self._make_llm()
+        captured: list = []
+
+        async def _capture_agenerate(messages_batch, *a, **kw):
+            captured.extend(messages_batch)
+            return ChatResult(
+                generations=[ChatGeneration(message=AIMessage(content="ok"))]
+            )
+
+        llm._agenerate = _capture_agenerate
+
+        respx.post(_RECALL_URL).mock(
+            return_value=_mock_recall([
+                {"blob_id": "b1", "text": "User loves coffee", "distance": 0.05}
+            ])
+        )
+        respx.post(_ANALYZE_URL).mock(return_value=_mock_analyze())
+
+        smart_llm = with_memwal_langchain(
+            llm, key=_KEY_HEX, account_id=_ACCOUNT_ID, server_url=_SERVER, auto_save=False
+        )
+        blocks = [
+            {"type": "text", "text": "Base instructions", "cache_control": {"type": "ephemeral"}}
+        ]
+        sys_msg = SystemMessage(content=blocks, id="sys-123", additional_kwargs={"source": "test"})
+        await smart_llm._agenerate([[sys_msg, HumanMessage("What do I like?")]])
+
+        assert len(captured) == 1
+        injected = captured[0]
+        assert isinstance(injected[0], SystemMessage)
+        assert injected[0].id == "sys-123"
+        assert injected[0].additional_kwargs == {"source": "test"}
+        assert isinstance(injected[0].content, list)
+        assert len(injected[0].content) == 2
+        assert injected[0].content[0] == blocks[0]
+        assert "untrusted data" in injected[0].content[1]["text"]
+
     @respx.mock
     async def test_no_memories_found_no_injection(self) -> None:
         """When no memories match, the message list is passed unchanged."""

memwal-0.1.11.dev8/tests/test_retry_after_http_date.py

@@ -0,0 +1,160 @@
+"""Tests for HTTP-date Retry-After header parsing and arithmetic overflow protection."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from email.utils import format_datetime
+from typing import Optional
+
+import pytest
+
+from memwal.client import (
+    MemWal,
+    _clamped_retry_after_ms,
+    _HttpStatusError,
+    _positive_retry_ms,
+    _retry_after_ms,
+)
+
+
+def _err(
+    retry_after: Optional[str] = None,
+    body: Optional[str] = None,
+) -> _HttpStatusError:
+    return _HttpStatusError(429, body or "{}", retry_after=retry_after)
+
+
+def test_positive_retry_ms_delta_seconds() -> None:
+    assert _positive_retry_ms("45") == 45000
+    assert _positive_retry_ms(45) == 45000
+    assert _positive_retry_ms("0.5") == 500
+    assert _positive_retry_ms(0.25) == 250
+
+
+def test_positive_retry_ms_invalid_or_non_positive() -> None:
+    assert _positive_retry_ms(0) is None
+    assert _positive_retry_ms("0") is None
+    assert _positive_retry_ms("-5") is None
+    assert _positive_retry_ms("invalid") is None
+    assert _positive_retry_ms(None) is None
+    assert _positive_retry_ms(float("nan")) is None
+    assert _positive_retry_ms(float("inf")) is None
+
+
+def test_positive_retry_ms_overflow_protection() -> None:
+    # 1e308 is finite float, but 1e308 * 1000 overflows to infinity
+    assert _positive_retry_ms("1e308") is None
+    assert _positive_retry_ms(1e308) is None
+
+
+def test_retry_after_http_date_in_future() -> None:
+    future_time = datetime.now(timezone.utc) + timedelta(seconds=45)
+    future_header = format_datetime(future_time, usegmt=True)
+
+    err = _err(retry_after=future_header)
+    delay = _retry_after_ms(err)
+    # Delay should be approximately 45,000 ms (allowing slight test execution variance)
+    assert 40000 <= delay <= 46000
+
+
+def test_retry_after_http_date_takes_priority_over_json() -> None:
+    future_time = datetime.now(timezone.utc) + timedelta(seconds=60)
+    future_header = format_datetime(future_time, usegmt=True)
+    body = '{"retry_after_seconds": 10}'
+
+    err = _err(retry_after=future_header, body=body)
+    delay = _retry_after_ms(err)
+    assert 55000 <= delay <= 61000
+
+
+def test_retry_after_http_date_in_past_falls_back_to_json() -> None:
+    past_time = datetime.now(timezone.utc) - timedelta(seconds=10)
+    past_header = format_datetime(past_time, usegmt=True)
+    body = '{"retry_after_seconds": 15}'
+
+    err = _err(retry_after=past_header, body=body)
+    assert _retry_after_ms(err) == 15000
+
+
+def test_retry_after_http_date_in_past_returns_zero_when_no_json() -> None:
+    past_time = datetime.now(timezone.utc) - timedelta(seconds=10)
+    past_header = format_datetime(past_time, usegmt=True)
+
+    err = _err(retry_after=past_header)
+    assert _retry_after_ms(err) == 0
+
+
+def test_retry_after_malformed_header_falls_back_to_json() -> None:
+    err = _err(retry_after="Not A Valid Date Or Number", body='{"retry_after_seconds": 25}')
+    assert _retry_after_ms(err) == 25000
+
+
+def test_retry_after_malformed_header_without_json_returns_zero() -> None:
+    err = _err(retry_after="invalid-header")
+    assert _retry_after_ms(err) == 0
+
+
+def test_retry_after_overflowing_number_falls_back_to_json() -> None:
+    err = _err(retry_after="1e308", body='{"retry_after_seconds": 30}')
+    assert _retry_after_ms(err) == 30000
+
+
+def test_clamped_retry_after_ms_with_http_date(monkeypatch: pytest.MonkeyPatch) -> None:
+    fixed_now = 1_000_000
+    monkeypatch.setattr("memwal.client._now_ms", lambda: fixed_now)
+
+    # Future date roughly 50s ahead
+    future_time = datetime.now(timezone.utc) + timedelta(seconds=50)
+    future_header = format_datetime(future_time, usegmt=True)
+    err = _err(retry_after=future_header)
+
+    # If remaining time is only 20s (deadline 1,020,000), clamped to 20,000
+    clamped = _clamped_retry_after_ms(err, deadline_ms=fixed_now + 20_000)
+    assert clamped == 20_000
+
+    # If remaining time is 100s, delay (~50,000 ms) is used
+    clamped_large = _clamped_retry_after_ms(err, deadline_ms=fixed_now + 100_000)
+    assert 45_000 <= clamped_large <= 51_000
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_honors_http_date_retry_after(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fixed_ts = 1700000000.0
+    monkeypatch.setattr("time.time", lambda: fixed_ts)
+    clock = {"now": int(fixed_ts * 1000)}
+    slept: list[int] = []
+
+    def fake_now_ms() -> int:
+        return clock["now"]
+
+    async def fake_sleep_ms(ms: int) -> None:
+        slept.append(ms)
+        clock["now"] += ms
+
+    monkeypatch.setattr("memwal.client._now_ms", fake_now_ms)
+    monkeypatch.setattr("memwal.client._sleep_ms", fake_sleep_ms)
+
+    client = MemWal.create(key="11" * 32, account_id="0x1", server_url="http://localhost:8000")
+    calls = {"n": 0}
+
+    # 429 Retry-After is 2 seconds into future
+    future_dt = datetime.fromtimestamp(fixed_ts, tz=timezone.utc) + timedelta(seconds=2)
+    http_date = format_datetime(future_dt, usegmt=True)
+
+    async def status(*_args: object, **_kwargs: object) -> dict:
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise _HttpStatusError(429, "{}", retry_after=http_date)
+        return {"job_id": "job-1", "status": "done", "blob_id": "b-1"}
+
+    monkeypatch.setattr(client, "_signed_request", status)
+
+    res = await client.wait_for_remember_job("job-1", timeout_ms=10_000)
+    assert res.blob_id == "b-1"
+    assert calls["n"] == 2
+    # First sleep is attempt 0 (0 ms), second sleep should be 2000 ms from Retry-After
+    assert len(slept) == 2
+    assert slept[0] == 0
+    assert slept[1] == 2000

memwal-0.1.11.dev8/tests/test_transport_retry.py

@@ -0,0 +1,195 @@
+"""Tests for network transport error retry and deadline bounding.
+
+Covers WALM-696 and GH #1000.
+"""
+
+from __future__ import annotations
+
+import httpx
+import pytest
+
+from memwal.client import (
+    MemWal,
+    MemWalRememberJobTimeout,
+    RememberBulkOptions,
+)
+
+
+def _client() -> MemWal:
+    return MemWal.create(key="11" * 32, account_id="0x1", server_url="http://localhost:8000")
+
+
+def _patch_clock(monkeypatch: pytest.MonkeyPatch) -> tuple[dict[str, int], list[int]]:
+    clock = {"now": 0}
+    slept: list[int] = []
+
+    def now_ms() -> int:
+        return clock["now"]
+
+    async def sleep_ms(ms: int) -> None:
+        slept.append(ms)
+        clock["now"] += ms
+
+    monkeypatch.setattr("memwal.client._now_ms", now_ms)
+    monkeypatch.setattr("memwal.client._sleep_ms", sleep_ms)
+    return clock, slept
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_retries_connect_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    _patch_clock(monkeypatch)
+    client = _client()
+    calls = {"n": 0}
+
+    async def status(*_args: object, **_kwargs: object) -> dict:
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise httpx.ConnectError("simulated connection drop")
+        return {
+            "job_id": "job-1",
+            "status": "done",
+            "blob_id": "blob-1",
+            "owner": "0x1",
+            "namespace": "default",
+        }
+
+    monkeypatch.setattr(client, "_signed_request", status)
+
+    done = await client.wait_for_remember_job("job-1", poll_interval_ms=100, timeout_ms=5000)
+    assert done.blob_id == "blob-1"
+    assert calls["n"] == 2
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_retries_read_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+    _patch_clock(monkeypatch)
+    client = _client()
+    calls = {"n": 0}
+
+    async def status(*_args: object, **_kwargs: object) -> dict:
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise httpx.ReadTimeout("simulated socket read timeout")
+        return {
+            "job_id": "job-2",
+            "status": "done",
+            "blob_id": "blob-2",
+            "owner": "0x1",
+            "namespace": "default",
+        }
+
+    monkeypatch.setattr(client, "_signed_request", status)
+
+    done = await client.wait_for_remember_job("job-2", poll_interval_ms=100, timeout_ms=5000)
+    assert done.blob_id == "blob-2"
+    assert calls["n"] == 2
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_times_out_with_http_0_message(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock, slept = _patch_clock(monkeypatch)
+    client = _client()
+    calls = {"n": 0}
+
+    async def failing(*_args: object, **_kwargs: object) -> dict:
+        calls["n"] += 1
+        clock["now"] += 100
+        raise httpx.ConnectError("network unreachable")
+
+    monkeypatch.setattr(client, "_signed_request", failing)
+
+    with pytest.raises(MemWalRememberJobTimeout) as exc_info:
+        await client.wait_for_remember_job("job-fail", poll_interval_ms=100, timeout_ms=500)
+
+    err = exc_info.value
+    assert err.last_refusal == 0
+    assert err.status == 504
+    assert "last poll: HTTP 0" in str(err)
+    assert calls["n"] > 1
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_job_bounds_poll_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+    clock, _ = _patch_clock(monkeypatch)
+    client = _client()
+    captured_timeouts: list[float] = []
+
+    async def capture(*_args: object, **kwargs: object) -> dict:
+        timeout = kwargs.get("timeout")
+        if timeout is not None:
+            captured_timeouts.append(timeout)
+        return {
+            "job_id": "job-bound",
+            "status": "done",
+            "blob_id": "blob-bound",
+            "owner": "0x1",
+            "namespace": "default",
+        }
+
+    monkeypatch.setattr(client, "_signed_request", capture)
+
+    clock["now"] = 1000
+    # timeout_ms=2000 -> deadline=3000 -> remaining=2.0s
+    await client.wait_for_remember_job("job-bound", timeout_ms=2000)
+    assert len(captured_timeouts) == 1
+    assert captured_timeouts[0] == pytest.approx(2.0, rel=1e-2)
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_jobs_bulk_retries_transport_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _patch_clock(monkeypatch)
+    client = _client()
+    calls = {"n": 0}
+
+    async def bulk_status(job_ids: list[str], timeout: float | None = None):
+        from memwal.types import RememberBulkStatusItem, RememberBulkStatusResult
+
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise httpx.ConnectError("simulated bulk network drop")
+        return RememberBulkStatusResult(
+            results=[
+                RememberBulkStatusItem(
+                    job_id="bulk-1",
+                    status="done",
+                    blob_id="blob-bulk-1",
+                )
+            ]
+        )
+
+    monkeypatch.setattr(client, "get_remember_bulk_status", bulk_status)
+
+    res = await client.wait_for_remember_jobs(
+        ["bulk-1"],
+        opts=RememberBulkOptions(poll_interval_ms=100, timeout_ms=5000),
+    )
+    assert len(res.results) == 1
+    assert res.results[0].status == "done"
+    assert res.results[0].blob_id == "blob-bulk-1"
+    assert calls["n"] == 2
+
+
+@pytest.mark.asyncio
+async def test_wait_for_remember_jobs_bulk_timeout_on_persistent_transport_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    clock, _ = _patch_clock(monkeypatch)
+    client = _client()
+
+    async def bulk_failing(job_ids: list[str], timeout: float | None = None):
+        clock["now"] += 100
+        raise httpx.ConnectError("persistent bulk network drop")
+
+    monkeypatch.setattr(client, "get_remember_bulk_status", bulk_failing)
+
+    res = await client.wait_for_remember_jobs(
+        ["bulk-dead"],
+        opts=RememberBulkOptions(poll_interval_ms=100, timeout_ms=500),
+    )
+    assert len(res.results) == 1
+    assert res.results[0].status == "timeout"
+    assert "last poll: HTTP 0" in (res.results[0].error or "")