memwal 0.2.2.dev1__tar.gz → 0.2.2.dev3__tar.gz

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/CHANGELOG.md

@@ -12,6 +12,8 @@ Unreleased.
 
 - Shield shared `_build_seal_session` and `_resolve_owner` initialization tasks with `asyncio.shield`, clear the shared task slot via a completion callback that consumes exceptions on orphaned tasks, and cancel/drain in-flight initialization tasks in `close()` so cancelling one concurrent caller does not abort sibling callers or leave unretrieved task exceptions. (#1029)
 - `health`, `ask`, `restore`, `list_namespaces`, `remember_manual`, and `recall` raise `MemWalError` naming the endpoint and field when a 2xx response omits a required field. They used to raise a bare `KeyError` that callers catching `MemWalError` never saw. (#1250, #1256)
+- `ask()` rejects a blank `question` and a `limit` that is not a positive integer before it signs the request. A NaN `limit` used to serialize as an invalid-JSON `NaN` token, and negative or fractional values were sent as-is. (#1249, #1255)
+- `recall()` rejects a blank `query` and a `max_distance` that is NaN, infinite, negative, or not a number before it signs the request, and `MemWalMock.recall()` rejects the same `max_distance`. A NaN or negative threshold used to return an empty page that looked like an empty namespace. (#1248, #1254)
 
 ## 0.2.1
 

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.2.2.dev1
+Version: 0.2.2.dev3
 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
@@ -181,7 +181,7 @@ memwal = MemWal.create(
 |-------|-------------|
 | `prod` | `https://relayer.memory.walrus.xyz` |
 | `dev` | `https://relayer.dev.memwal.ai` |
-| `staging` | `https://relayer-staging.memory.walrus.xyz` |
+| `staging` | `https://relayer.dev.memwal.ai` |
 
 Precedence: any explicit **`server_url` wins over `env`**, including the hosted
 default. `env` applies only when `server_url` is omitted (`None`). An unknown

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/README.md

@@ -140,7 +140,7 @@ memwal = MemWal.create(
 |-------|-------------|
 | `prod` | `https://relayer.memory.walrus.xyz` |
 | `dev` | `https://relayer.dev.memwal.ai` |
-| `staging` | `https://relayer-staging.memory.walrus.xyz` |
+| `staging` | `https://relayer.dev.memwal.ai` |
 
 Precedence: any explicit **`server_url` wins over `env`**, including the hosted
 default. `env` applies only when `server_url` is omitted (`None`). An unknown

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/memwal/__init__.py

@@ -128,4 +128,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.2.2.dev1"
+__version__ = "0.2.2.dev3"

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/memwal/client.py

@@ -86,6 +86,7 @@ from .utils import (
     sha256_hex,
     sign_message,
     sign_sui_personal_message,
+    validate_max_distance,
 )
 
 T = TypeVar("T")
@@ -160,6 +161,18 @@ def _require(data: object, field: str, endpoint: str) -> Any:
     return data[field]
 
 
+def _require_positive_int(value: object, name: str) -> None:
+    """Reject anything but a positive ``int`` before it is signed (#1249).
+
+    ``json.dumps`` writes ``float("nan")`` as a bare ``NaN`` token, which is
+    not valid JSON, and negative or fractional values were forwarded as-is.
+    ``bool`` is an ``int`` subclass and is rejected explicitly.
+    """
+
+    if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+        raise ValueError(f"{name} must be a positive integer, got {value!r}")
+
+
 IDEMPOTENCY_BUCKET_MS = 30 * 60 * 1000
 
 
@@ -1194,7 +1207,9 @@ class MemWal:
             sort = params.sort
         else:
             query_text = query
+        _reject_blank_text(query_text, "query cannot be empty")
         _check_limit(limit)
+        validate_max_distance(max_distance)
         body = {
             "query": query_text,
             "limit": limit,
@@ -1371,6 +1386,8 @@ class MemWal:
         Returns:
             :class:`AskResult` with answer, memories_used count, and memories list.
         """
+        _reject_blank_text(question, "question cannot be empty")
+        _require_positive_int(limit, "limit")
         data = await self._signed_request("POST", "/api/ask", {
             "question": question,
             "limit": limit,

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/memwal/mock.py

@@ -38,6 +38,7 @@ from .types import (
     RememberResult,
     RestoreResult,
 )
+from .utils import validate_max_distance
 
 _MOCK_NAMESPACE_EPOCH = datetime(2026, 1, 1, tzinfo=timezone.utc)
 
@@ -285,6 +286,7 @@ class MemWalMock:
             query_text = query
         _validate_text(query_text, "query")
         _check_limit(limit)
+        validate_max_distance(max_distance)
         if sort not in (None, "relevance", "recent"):
             raise ValueError("sort must be 'relevance' or 'recent'")
         resolved_namespace = self._namespace if namespace is None else namespace

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/memwal/types.py

@@ -24,7 +24,7 @@ DEFAULT_SERVER_URL = "https://relayer.memory.walrus.xyz"
 ENV_PRESETS = {
     "prod": "https://relayer.memory.walrus.xyz",
     "dev": "https://relayer.dev.memwal.ai",
-    "staging": "https://relayer-staging.memory.walrus.xyz",
+    "staging": "https://relayer.dev.memwal.ai",
     "local": "http://127.0.0.1:8000",
 }
 

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/memwal/utils.py

@@ -9,8 +9,9 @@ from __future__ import annotations
 
 import base64
 import hashlib
+import math
 from datetime import datetime, timezone
-from typing import Tuple, Union
+from typing import Optional, Tuple, Union
 
 import nacl.signing
 
@@ -373,3 +374,23 @@ def sign_sui_personal_message(
     public_key_bytes = bytes(signing_key.verify_key)
     serialized = bytes([_SUI_ED25519_SCHEME_FLAG]) + signature_bytes + public_key_bytes
     return base64.b64encode(serialized).decode("ascii")
+
+
+def validate_max_distance(max_distance: Optional[float]) -> None:
+    """Reject a ``max_distance`` that would silently drop every hit (#1248).
+
+    The recall filter keeps ``distance < max_distance``. Every comparison with
+    NaN is False and real distances are never negative, so NaN or a negative
+    threshold returns an empty page that looks like an empty namespace.
+    Mirrors the TypeScript ``maxDistance`` guard (#1227).
+    """
+
+    if max_distance is None:
+        return
+    if (
+        isinstance(max_distance, bool)
+        or not isinstance(max_distance, (int, float))
+        or not math.isfinite(max_distance)
+        or max_distance < 0
+    ):
+        raise ValueError("max_distance must be a non-negative finite number")

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/notebooks/walrus_memory_python_sdk.ipynb

@@ -30,7 +30,7 @@
     "- optional OpenAI and LangChain middleware examples\n",
     "- cleanup and troubleshooting\n",
     "\n",
-    "The notebook defaults to `staging` for test credentials and uses Railway-backed Walrus Memory domains: `https://relayer-staging.memory.walrus.xyz` for staging and `https://relayer.memory.walrus.xyz` for production. You can switch to `prod` when you have production credentials.\n"
+    "The notebook defaults to `staging` for test credentials and uses Railway-backed Walrus Memory domains: `https://relayer.dev.memwal.ai` for staging and `https://relayer.memory.walrus.xyz` for production. You can switch to `prod` when you have production credentials.\n"
    ]
   },
   {
@@ -91,7 +91,7 @@
     "\n",
     "ALLOWED_ENVS = {\"staging\", \"prod\"}\n",
     "SERVER_URL_PRESETS = {\n",
-    "    \"staging\": \"https://relayer-staging.memory.walrus.xyz\",\n",
+    "    \"staging\": \"https://relayer.dev.memwal.ai\",\n",
     "    \"prod\": \"https://relayer.memory.walrus.xyz\",\n",
     "}\n",
     "DEFAULT_ENV = \"staging\"\n",

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/pyproject.toml

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

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/run_tests.py

@@ -26,7 +26,7 @@ BOLD   = "\033[1m"
 DIM    = "\033[2m"
 RESET  = "\033[0m"
 
-SERVER_URL  = os.environ.get("MEMWAL_SERVER_URL", "https://relayer-staging.memory.walrus.xyz")
+SERVER_URL  = os.environ.get("MEMWAL_SERVER_URL", "https://relayer.dev.memwal.ai")
 PRIVATE_KEY = os.environ.get("MEMWAL_PRIVATE_KEY", "")
 ACCOUNT_ID  = os.environ.get("MEMWAL_ACCOUNT_ID", "")
 HAS_KEY     = bool(PRIVATE_KEY and ACCOUNT_ID)

memwal-0.2.2.dev3/tests/test_ask_validation.py

@@ -0,0 +1,56 @@
+"""``ask()`` validates its question and limit before signing (#1249).
+
+``remember``/``analyze``/``embed`` reject blank text before signing; ``ask``
+did not, so an empty question reached the LLM-backed endpoint. Its
+``limit`` was also forwarded verbatim, including a literal ``NaN`` token
+that is not valid JSON.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from typing import Any, List
+
+import nacl.signing
+import pytest
+
+from memwal import MemWal
+from memwal.utils import bytes_to_hex
+
+_KEY_HEX = bytes_to_hex(bytes(nacl.signing.SigningKey(b"\x01" * 32)))
+
+
+def _client(sent: List[str]) -> MemWal:
+    client = MemWal.create(key=_KEY_HEX, account_id="0x1", server_url="https://relayer.example")
+
+    async def fake_signed_request(method, path, body, **kwargs):  # type: ignore[no-untyped-def]
+        # Same serialization the real request path uses for the signed body.
+        sent.append(json.dumps(body))
+        return {"answer": "hi", "memories_used": 0, "memories": []}
+
+    client._signed_request = fake_signed_request  # type: ignore[method-assign]
+    return client
+
+
+@pytest.mark.parametrize("question", ["", " ", "\t\n"])
+async def test_blank_question_rejected_before_signing(question: str) -> None:
+    sent: List[str] = []
+    with pytest.raises(ValueError, match="question cannot be empty"):
+        await _client(sent).ask(question)
+    assert sent == []
+
+
+@pytest.mark.parametrize("limit", [math.nan, math.inf, -1, 0, 2.5, "5", True, None])
+async def test_bad_limit_rejected_before_signing(limit: Any) -> None:
+    sent: List[str] = []
+    with pytest.raises(ValueError, match="limit must be a positive integer"):
+        await _client(sent).ask("q?", limit=limit)
+    assert sent == []
+
+
+async def test_valid_call_is_sent_unchanged() -> None:
+    sent: List[str] = []
+    result = await _client(sent).ask("q?", limit=3)
+    assert result.answer == "hi"
+    assert json.loads(sent[0]) == {"question": "q?", "limit": 3, "namespace": "default"}

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/tests/test_env_presets.py

@@ -19,7 +19,7 @@ ACCOUNT = "0x" + "ab" * 32
     [
         ("prod", "https://relayer.memory.walrus.xyz"),
         ("dev", "https://relayer.dev.memwal.ai"),
-        ("staging", "https://relayer-staging.memory.walrus.xyz"),
+        ("staging", "https://relayer.dev.memwal.ai"),
         ("local", "http://127.0.0.1:8000"),
     ],
 )
@@ -52,7 +52,7 @@ def test_unknown_env_raises():
 
 def test_create_threads_env_through_to_client():
     client = MemWal.create(key=KEY, account_id=ACCOUNT, env="staging")
-    assert client._server_url == "https://relayer-staging.memory.walrus.xyz"
+    assert client._server_url == "https://relayer.dev.memwal.ai"
 
 
 def test_sync_create_threads_env_through():

{memwal-0.2.2.dev1 → memwal-0.2.2.dev3}/tests/test_integration.py

@@ -2,7 +2,7 @@
 """
 Integration tests for the Walrus Memory Python SDK against a live server.
 
-Targets MEMWAL_SERVER_URL (default: https://relayer-staging.memory.walrus.xyz).
+Targets MEMWAL_SERVER_URL (default: https://relayer.dev.memwal.ai).
 
 No-auth tests (always run, no env vars needed):
   - /health endpoint
@@ -31,7 +31,7 @@ Usage:
   # Run against staging using env vars
   export MEMWAL_PRIVATE_KEY="<your-ed25519-delegate-private-key-hex>"
   export MEMWAL_ACCOUNT_ID="0x-your-walrus-memory-account-id"
-  export MEMWAL_SERVER_URL="https://relayer-staging.memory.walrus.xyz"
+  export MEMWAL_SERVER_URL="https://relayer.dev.memwal.ai"
   python -m pytest tests/test_integration.py -v
 """
 
@@ -54,7 +54,7 @@ pytestmark = pytest.mark.integration
 
 # ── Config ───────────────────────────────────────────────────────────────────
 
-SERVER_URL = os.environ.get("MEMWAL_SERVER_URL", "https://relayer-staging.memory.walrus.xyz")
+SERVER_URL = os.environ.get("MEMWAL_SERVER_URL", "https://relayer.dev.memwal.ai")
 PRIVATE_KEY_HEX = os.environ.get("MEMWAL_PRIVATE_KEY", "")
 ACCOUNT_ID = os.environ.get("MEMWAL_ACCOUNT_ID", "")
 
@@ -98,6 +98,9 @@ def _async_client(namespace: str = _E2E_NAMESPACE) -> MemWal:
 # ── Helpers ───────────────────────────────────────────────────────────────────
 
 
+_HTTP_CLIENT = httpx.Client(timeout=30, transport=httpx.HTTPTransport(retries=3))
+
+
 def _raw_signed_request(
     method: str,
     path: str,
@@ -125,20 +128,19 @@ def _raw_signed_request(
     signature_hex = signed.signature.hex()
     pub_key_hex = pub_key_override or signing_key.verify_key.encode().hex()
 
-    with httpx.Client(timeout=30) as client:
-        return client.request(
-            method,
-            f"{base_url}{path}",
-            content=body_bytes,
-            headers={
-                "Content-Type": "application/json",
-                "x-public-key": pub_key_hex,
-                "x-signature": signature_hex,
-                "x-timestamp": timestamp,
-                "x-nonce": nonce,
-                "x-account-id": ACCOUNT_ID or "0x0",
-            },
-        )
+    return _HTTP_CLIENT.request(
+        method,
+        f"{base_url}{path}",
+        content=body_bytes,
+        headers={
+            "Content-Type": "application/json",
+            "x-public-key": pub_key_hex,
+            "x-signature": signature_hex,
+            "x-timestamp": timestamp,
+            "x-nonce": nonce,
+            "x-account-id": ACCOUNT_ID or "0x0",
+        },
+    )
 
 
 # ── No-auth tests (always run) ────────────────────────────────────────────────
@@ -168,8 +170,7 @@ class TestAuthRejection:
 
     def test_unsigned_request_rejected(self) -> None:
         """Request with no auth headers → 401."""
-        with httpx.Client(timeout=30) as client:
-            resp = client.post(f"{SERVER_URL}/api/remember", json=self._body)
+        resp = _HTTP_CLIENT.post(f"{SERVER_URL}/api/remember", json=self._body)
         assert resp.status_code == 401, f"Expected 401, got {resp.status_code}: {resp.text}"
 
     def test_wrong_signature_rejected(self) -> None:

memwal-0.2.2.dev3/tests/test_recall_validation.py

@@ -0,0 +1,84 @@
+"""``recall()`` input validation in the real client and the mock (#1248).
+
+Ports the TypeScript guards from #1228 (blank query) and #1227 (NaN /
+negative ``maxDistance``). Before this, the Python client signed an empty
+query, and a NaN or negative ``max_distance`` silently dropped every hit the
+relayer returned, which looked exactly like an empty namespace.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any, Dict, List
+
+import nacl.signing
+import pytest
+
+from memwal import MemWal, MemWalMock, RecallParams
+from memwal.utils import bytes_to_hex
+
+_KEY_HEX = bytes_to_hex(bytes(nacl.signing.SigningKey(b"\x01" * 32)))
+_HITS = {
+    "results": [
+        {"blob_id": "b1", "text": "coffee", "distance": 0.5},
+        {"blob_id": "b2", "text": "tea", "distance": 1.0},
+    ],
+    "total": 2,
+}
+
+_BAD_DISTANCES = [math.nan, -1.0, -0.001, math.inf, "0.5", True]
+
+
+def _client(sent: List[Dict[str, Any]]) -> MemWal:
+    client = MemWal.create(key=_KEY_HEX, account_id="0x1", server_url="https://relayer.example")
+
+    async def fake_signed_request(method, path, body, **kwargs):  # type: ignore[no-untyped-def]
+        sent.append(body)
+        return _HITS
+
+    client._signed_request = fake_signed_request  # type: ignore[method-assign]
+    return client
+
+
+@pytest.mark.parametrize("query", ["", "   ", "\t\n"])
+async def test_client_rejects_blank_query_before_signing(query: str) -> None:
+    sent: List[Dict[str, Any]] = []
+    with pytest.raises(ValueError, match="query cannot be empty"):
+        await _client(sent).recall(query)
+    with pytest.raises(ValueError, match="query cannot be empty"):
+        await _client(sent).recall(RecallParams(query=query))
+    assert sent == []
+
+
+@pytest.mark.parametrize("max_distance", _BAD_DISTANCES)
+async def test_client_rejects_bad_max_distance_before_signing(max_distance: Any) -> None:
+    sent: List[Dict[str, Any]] = []
+    with pytest.raises(ValueError, match="max_distance must be a non-negative finite number"):
+        await _client(sent).recall("coffee", max_distance=max_distance)
+    with pytest.raises(ValueError, match="max_distance must be a non-negative finite number"):
+        await _client(sent).recall(RecallParams(query="coffee", max_distance=max_distance))
+    assert sent == []
+
+
+async def test_client_valid_max_distance_still_filters() -> None:
+    sent: List[Dict[str, Any]] = []
+    result = await _client(sent).recall("coffee", max_distance=0.75)
+    assert [m.blob_id for m in result.results] == ["b1"]
+    assert result.total == 2
+    zero = await _client(sent).recall("coffee", max_distance=0)
+    assert zero.results == []
+
+
+@pytest.mark.parametrize("max_distance", _BAD_DISTANCES)
+async def test_mock_rejects_bad_max_distance(max_distance: Any) -> None:
+    mock = MemWalMock.create()
+    await mock.remember("I like coffee")
+    with pytest.raises(ValueError, match="max_distance must be a non-negative finite number"):
+        await mock.recall("coffee", max_distance=max_distance)
+
+
+async def test_mock_valid_max_distance_still_filters() -> None:
+    mock = MemWalMock.create()
+    await mock.remember("I like coffee")
+    result = await mock.recall("coffee", max_distance=2.0)
+    assert len(result.results) == 1