memwal 0.1.11.dev3__tar.gz → 0.1.11.dev5__tar.gz

{memwal-0.1.11.dev3 → memwal-0.1.11.dev5}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # memwal
 
+## Unreleased
+
+### Fixed
+
+- `remember`, `remember_bulk`, `analyze`, and `embed` reject whitespace-only text before the request. A blank body used to be accepted and then sit until the caller timed out. (#1129)
+- A 401 `AUTH_REJECTED` now says a wallet address is not a MemWal account ID. (#1132)
+- `wait_for_remember_jobs` / `remember_bulk_and_wait` no longer return a batch they could not read as if it were still uploading. When every status poll is rate-limited, the wait makes one confirming read and raises `MemWalRateLimited` (`status` 429, `job_ids`, `retry_after`) if that is refused too. An item still unsettled at the deadline names its last known status, or says no read got through. (WALM-671, #967)
+
 ## 0.1.12
 
 ### Fixed

{memwal-0.1.11.dev3 → memwal-0.1.11.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.1.11.dev3
+Version: 0.1.11.dev5
 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.dev3 → memwal-0.1.11.dev5}/memwal/__init__.py

@@ -27,6 +27,7 @@ from .client import (
     MemWalClockDriftError,
     MemWalCompatibilityError,
     MemWalError,
+    MemWalRateLimited,
     MemWalRememberJobFailed,
     MemWalRememberJobNotFound,
     MemWalRememberJobTimeout,
@@ -82,6 +83,7 @@ __all__ = [
     "MemWalError",
     "MemWalCompatibilityError",
     "MemWalClockDriftError",
+    "MemWalRateLimited",
     "MemWalRememberJobFailed",
     "MemWalRememberJobNotFound",
     "MemWalRememberJobTimeout",
@@ -126,4 +128,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.1.11.dev3"
+__version__ = "0.1.11.dev5"

{memwal-0.1.11.dev3 → memwal-0.1.11.dev5}/memwal/client.py

@@ -96,7 +96,8 @@ PACKAGE_VERSION_CHECK_TIMEOUT_S = 10.0
 SEAL_SESSION_SAFETY_MARGIN_MS = 30_000
 AUTH_REJECTED_MESSAGE = (
     "401 from relayer: typically wrong private key, key not registered on this "
-    "account, account ID mismatch, or staging/mainnet mismatch. Check .env.local "
+    "account, account ID mismatch (a wallet address is not a MemWal account ID), "
+    "or staging/mainnet mismatch. Check .env.local "
     "and dashboard credentials. Full troubleshooting: "
     "https://docs.wal.app/walrus-memory/troubleshooting/overview#401-auth_rejected-errors"
 )
@@ -121,6 +122,18 @@ def _server_url_for_log(parsed: ParseResult) -> str:
     return f"{parsed.scheme}://{host}"
 
 
+def _reject_blank_text(text: object, message: str = "Text cannot be empty") -> None:
+    """Reject empty and whitespace-only text before a request is sent.
+
+    The relayer does the same (#1129). Failing here means an older relayer
+    cannot accept the job and leave the caller polling until timeout.
+    Non-blank text is not trimmed.
+    """
+
+    if not isinstance(text, str) or not text.strip():
+        raise ValueError(message)
+
+
 def normalize_server_url(url: str) -> str:
     """Strip a trailing slash and warn on plaintext HTTP to a remote host.
 
@@ -414,6 +427,7 @@ class MemWal:
             :class:`RememberAcceptedResult` with ``job_id`` and initial
             status (``"pending"``).
         """
+        _reject_blank_text(text)
         resolved_namespace = namespace or self._namespace
         request_identity = f"{resolved_namespace}\0{text}"
         generated_key = idempotency_key is None
@@ -569,6 +583,8 @@ class MemWal:
 
         if not items:
             raise ValueError("remember_bulk_async: items must be a non-empty array")
+        for index, item in enumerate(items):
+            _reject_blank_text(item.text, f"items[{index}].text cannot be empty")
 
         payload_items: List[Dict[str, Any]] = [
             {
@@ -662,6 +678,31 @@ class MemWal:
         attempt = 0
         saw_rate_limit = False
         retry_after_ms = 0
+        last_seen: Dict[str, RememberBulkStatusItem] = {}
+        last_refusal: Optional[int] = None
+        # Whether any status read got through. An item missing from an answer
+        # was not refused, so it must not be reported as if it had been.
+        answered = False
+
+        def settle(item: RememberBulkStatusItem) -> bool:
+            last_seen[item.job_id] = item
+            if item.status == "done":
+                results[item.job_id] = RememberBulkItemResult(
+                    id=item.job_id,
+                    blob_id=item.blob_id or "",
+                    status="done",
+                    error=None,
+                )
+                return True
+            if item.status in ("failed", "not_found"):
+                results[item.job_id] = RememberBulkItemResult(
+                    id=item.job_id,
+                    blob_id=item.blob_id or "",
+                    status="failed",
+                    error=item.error,
+                )
+                return True
+            return False
 
         while pending and _now_ms() < deadline_ms:
             if retry_after_ms > 0:
@@ -675,40 +716,66 @@ class MemWal:
                 batch = await self.get_remember_bulk_status(pending)
             except _HttpStatusError as err:
                 if _is_transient_polling_status(err.status):
+                    last_refusal = err.status
                     if err.status == 429:
                         saw_rate_limit = True
                         retry_after_ms = _clamped_retry_after_ms(err, deadline_ms)
                     continue
                 raise
+            answered = True
 
-            terminal_ids: Set[str] = set()
-            for item in batch.results:
-                if item.status == "done":
-                    results[item.job_id] = RememberBulkItemResult(
-                        id=item.job_id,
-                        blob_id=item.blob_id or "",
-                        status="done",
-                        error=None,
-                    )
-                    terminal_ids.add(item.job_id)
-                elif item.status in ("failed", "not_found"):
-                    results[item.job_id] = RememberBulkItemResult(
-                        id=item.job_id,
-                        blob_id=item.blob_id or "",
-                        status="failed",
-                        error=item.error,
-                    )
-                    terminal_ids.add(item.job_id)
+            terminal_ids: Set[str] = {
+                item.job_id
+                for item in batch.results
+                if item.job_id in pending and settle(item)
+            }
             pending = [jid for jid in pending if jid not in terminal_ids]
 
+        if opts.timeout_ms > 0 and len(pending) == len(job_ids) and not last_seen:
+            # Nothing settled and nothing was seen: the polls may all have been
+            # refused. Confirm with one direct read before reporting anything.
+            try:
+                probed = await self.get_remember_bulk_status(list(job_ids))
+            except _HttpStatusError as err:
+                if err.status == 429:
+                    # Header first, else the body's retry_after_seconds, so a
+                    # proxy that strips Retry-After does not lose the hint.
+                    wait_ms = _retry_after_ms(err)
+                    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.
+            else:
+                answered = True
+                settled = {
+                    item.job_id
+                    for item in probed.results
+                    if item.job_id in pending and settle(item)
+                }
+                pending = [jid for jid in pending if jid not in settled]
+
+        for job_id in pending:
+            seen = last_seen.get(job_id)
+            if seen is not None:
+                suffix = f": {_redact_internal_urls(seen.error)}" if seen.error else ""
+                error = f"still {seen.status} after {opts.timeout_ms}ms{suffix}"
+            elif answered:
+                error = "not in the relayer's status answer; this item may not be stored"
+            elif last_refusal is not None:
+                error = (
+                    f"no status read got through (last poll: HTTP {last_refusal}); "
+                    "this item may not be stored"
+                )
+            else:
+                error = f"polling timed out after {opts.timeout_ms}ms"
+            # Only the "no status read got through" message already names the 429.
+            names_rate_limit = seen is None and not answered and last_refusal == 429
+            if saw_rate_limit and not names_rate_limit:
+                error += "; wait hit a rate limit (429)"
+            results[job_id] = RememberBulkItemResult(
+                id=job_id, blob_id="", status="timeout", error=error
+            )
+
         ordered = [results[job_id] for job_id in job_ids]
-        if saw_rate_limit:
-            for item in ordered:
-                if item.status == "timeout":
-                    item.error = (
-                        f"polling timed out after {opts.timeout_ms}ms; "
-                        "wait hit a rate limit (429)"
-                    )
         succeeded = sum(1 for r in ordered if r.status == "done")
         failed = sum(1 for r in ordered if r.status == "failed")
         timed_out = sum(1 for r in ordered if r.status == "timeout")
@@ -847,6 +914,7 @@ class MemWal:
             :class:`AnalyzeResult` with extracted ``facts`` + per-fact
             ``job_ids`` for downstream polling.
         """
+        _reject_blank_text(text)
         body: Dict[str, Any] = {
             "text": text,
             "namespace": namespace or self._namespace,
@@ -919,6 +987,7 @@ class MemWal:
         :meth:`remember` (server handles embed + encrypt + upload).
         """
 
+        _reject_blank_text(text, "text cannot be empty")
         data = await self._signed_request(
             "POST",
             "/api/embed",
@@ -1601,6 +1670,24 @@ class MemWalRememberJobFailed(MemWalError):
         self.error = error
 
 
+class MemWalRateLimited(MemWalError):
+    """Every status read for a bulk wait was rate-limited, the confirming read
+    included, so none of its writes could be confirmed (GH #967). Status reads
+    count against the same delegate-key budget as writes."""
+
+    def __init__(self, job_ids: Sequence[str], retry_after: Optional[str] = None) -> None:
+        wait = f" after ~{retry_after}s" if retry_after else ""
+        super().__init__(
+            f"Walrus Memory rate-limited every status read for this batch, so none of its "
+            f"{len(job_ids)} writes could be confirmed. Do not treat them as stored: check them "
+            f"with get_remember_bulk_status(job_ids){wait}. Status reads count against the same "
+            "delegate-key budget as writes."
+        )
+        self.status = 429
+        self.job_ids = list(job_ids)
+        self.retry_after = retry_after
+
+
 class MemWalRememberJobTimeout(MemWalError):
     """Polling loop exceeded the configured timeout."""
 

{memwal-0.1.11.dev3 → memwal-0.1.11.dev5}/pyproject.toml

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

{memwal-0.1.11.dev3 → memwal-0.1.11.dev5}/tests/test_auth_rejected_message.py

@@ -12,6 +12,7 @@ from memwal.client import (
 
 def test_auth_rejected_message_points_to_troubleshooting_guide() -> None:
     assert "docs.wal.app/walrus-memory/troubleshooting/overview" in AUTH_REJECTED_MESSAGE
+    assert "wallet address" in AUTH_REJECTED_MESSAGE
 
 
 def test_auth_503_is_retryable_not_a_credential_failure() -> None:

memwal-0.1.11.dev5/tests/test_blank_text.py

@@ -0,0 +1,22 @@
+"""Whitespace-only text is rejected before a request is sent (#1129)."""
+
+from __future__ import annotations
+
+import pytest
+
+from memwal.client import _reject_blank_text
+
+
+@pytest.mark.parametrize("text", ["", " ", "\t", "\n", "  \t\n "])
+def test_blank_text_rejected(text: str) -> None:
+    with pytest.raises(ValueError, match="Text cannot be empty"):
+        _reject_blank_text(text)
+
+
+def test_padded_text_is_not_trimmed() -> None:
+    _reject_blank_text("  hello  ")
+
+
+def test_bulk_item_message_names_the_index() -> None:
+    with pytest.raises(ValueError, match=r"items\[0\].text cannot be empty"):
+        _reject_blank_text(" \t", "items[0].text cannot be empty")

{memwal-0.1.11.dev3 → memwal-0.1.11.dev5}/tests/test_client.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import base64
 import json
+import time
 from datetime import datetime, timedelta, timezone
 from typing import Any, Sequence
 
@@ -22,7 +23,9 @@ from memwal.client import (
     MemWalClockDriftError,
     MemWalCompatibilityError,
     MemWalError,
+    MemWalRateLimited,
     MemWalSync,
+    _HttpStatusError,
 )
 from memwal.types import (
     RecallManualOptions,
@@ -462,6 +465,99 @@ class TestRememberBulkAsync:
         assert [item.status for item in result.results] == ["done", "done"]
 
 
+class TestBulkWaitUnderRateLimit:
+    async def test_every_read_refused_raises_rate_limited(
+        self, memwal_client: MemWal
+    ) -> None:
+        ids = [f"job-{i}" for i in range(12)]
+
+        async def refused(job_ids: Sequence[str]) -> RememberBulkStatusResult:
+            raise _HttpStatusError(429, '{"error":"rate limited"}', retry_after="30")
+
+        memwal_client.get_remember_bulk_status = refused  # type: ignore[method-assign]
+        with pytest.raises(MemWalRateLimited) as exc:
+            await memwal_client.wait_for_remember_jobs(
+                ids, RememberBulkOptions(poll_interval_ms=1, timeout_ms=300)
+            )
+        assert exc.value.status == 429
+        assert exc.value.job_ids == ids
+        assert exc.value.retry_after == "30"
+        assert "none of its 12 writes could be confirmed" in str(exc.value)
+
+    async def test_rate_limited_reads_the_body_when_the_header_is_stripped(
+        self, memwal_client: MemWal
+    ) -> None:
+        async def refused(job_ids: Sequence[str]) -> RememberBulkStatusResult:
+            raise _HttpStatusError(429, '{"retry_after_seconds":45}')
+
+        memwal_client.get_remember_bulk_status = refused  # type: ignore[method-assign]
+        with pytest.raises(MemWalRateLimited) as exc:
+            await memwal_client.wait_for_remember_jobs(
+                ["job-1"], RememberBulkOptions(poll_interval_ms=1, timeout_ms=300)
+            )
+        assert exc.value.retry_after == "45"
+        assert "after ~45s" in str(exc.value)
+
+    async def test_confirming_read_settles_a_refused_wait(
+        self, memwal_client: MemWal
+    ) -> None:
+        start = time.monotonic()
+
+        async def probe_answers(job_ids: Sequence[str]) -> RememberBulkStatusResult:
+            # Refused for the whole 250ms wait; the read after the deadline is
+            # the probe. Time-based because jitter varies the poll count.
+            if time.monotonic() - start < 0.25:
+                raise _HttpStatusError(429, "{}")
+            return RememberBulkStatusResult(
+                results=[
+                    RememberBulkStatusItem(job_id="job-a", status="done", blob_id="blob-a"),
+                    RememberBulkStatusItem(
+                        job_id="job-b", status="failed", error="walrus upload failed"
+                    ),
+                ]
+            )
+
+        memwal_client.get_remember_bulk_status = probe_answers  # type: ignore[method-assign]
+        out = await memwal_client.wait_for_remember_jobs(
+            ["job-a", "job-b", "job-c"],
+            RememberBulkOptions(poll_interval_ms=1, timeout_ms=250),
+        )
+        assert [r.status for r in out.results] == ["done", "failed", "timeout"]
+        # A read did get through; it just left job-c out, so saying no read
+        # got through would be false.
+        assert "not in the relayer's status answer" in (out.results[2].error or "")
+
+    async def test_partly_settled_batch_is_returned(self, memwal_client: MemWal) -> None:
+        reads = 0
+
+        async def then_refused(job_ids: Sequence[str]) -> RememberBulkStatusResult:
+            nonlocal reads
+            reads += 1
+            if reads == 1:
+                return RememberBulkStatusResult(
+                    results=[
+                        RememberBulkStatusItem(
+                            job_id="job-a", status="done", blob_id="blob-a"
+                        ),
+                        RememberBulkStatusItem(
+                            job_id="job-b",
+                            status="running",
+                            error="still retrying this upload",
+                        ),
+                    ]
+                )
+            raise _HttpStatusError(429, "{}")
+
+        memwal_client.get_remember_bulk_status = then_refused  # type: ignore[method-assign]
+        out = await memwal_client.wait_for_remember_jobs(
+            ["job-a", "job-b"], RememberBulkOptions(poll_interval_ms=1, timeout_ms=300)
+        )
+        assert [r.status for r in out.results] == ["done", "timeout"]
+        assert "still running after 300ms: still retrying this upload" in (
+            out.results[1].error or ""
+        )
+
+
 # ============================================================
 # recall() tests
 # ============================================================

{memwal-0.1.11.dev3 → memwal-0.1.11.dev5}/tests/test_polling_delay.py

@@ -139,5 +139,6 @@ async def test_bulk_timeout_names_429_and_keeps_unreturned_jobs_pending(
     assert settled.results[0].status == "done"
     assert settled.results[1].status == "timeout"
     assert settled.results[1].error == (
-        "polling timed out after 800ms; wait hit a rate limit (429)"
+        "not in the relayer's status answer; this item may not be stored; "
+        "wait hit a rate limit (429)"
     )