memwal 0.2.2.dev2__tar.gz → 0.2.2.dev4__tar.gz

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/CHANGELOG.md

@@ -6,10 +6,12 @@ Unreleased.
 
 ### Added
 
+- `forget(namespace=None)` (and alias `forget_namespace(namespace=None)`) on `MemWal` and `MemWalSync` wraps `POST /api/forget` and returns `ForgetResult` (`deleted`, `namespace`, `owner`). It deletes the owner's index rows for the namespace while leaving Walrus blobs in place. `MemWalMock` and `MemWalMockSync` retain synchronous per-blob `forget(blob_id) -> bool` and add `forget_namespace(namespace=None) -> ForgetResult` for namespace erasure. (#1061)
 - `MemWal.destroy()` and `MemWalSync.destroy()` (plus `close(clear_keys=True)`) zero the client's internal `bytearray` seed copy in place, clear `_private_key_hex`, drop `_signing_key` and cached SEAL session credentials, cancel in-flight initialization tasks, and reject any subsequent or in-flight operation with `MemWalError`. `MemWal.create()` and `MemWalSync.create()` also accept 32-byte `bytes` / `bytearray` keys and copy caller `bytearray` buffers so `destroy()` leaves the caller's buffer intact. (#975)
 
 ### Fixed
 
+- `health()`, `compatibility()`, `_fetch_server_config()`, package-version preflight probes, and `_signed_request()` raise `MemWalJsonBodyError` (a `MemWalError` subclass carrying `.status`, `.endpoint`, and `.body`) instead of Python's raw `json.JSONDecodeError` when a 2xx response has an empty or non-JSON body. (#1219)
 - 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)

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.2.2.dev2
+Version: 0.2.2.dev4
 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
@@ -147,7 +147,7 @@ async def test_memory_flow():
     assert "dark mode" in result.results[0].text
 ```
 
-The mock supports remember/job polling, bulk remember, recall, analyze, embed, ask, health, restore, list_namespaces, `forget(blob_id)`, and `clear(namespace)`. For deterministic behavior, `analyze` stores its full input as one fact instead of invoking an LLM extractor. Its simple relevance score is for application tests, not production search-quality evaluation.
+The mock supports remember/job polling, bulk remember, recall, analyze, embed, ask, health, restore, list_namespaces, `forget(blob_id)` (synchronous per-blob deletion returning `bool`), `forget_namespace(namespace?)` (namespace erasure returning `ForgetResult`), and `clear(namespace?)`. For deterministic behavior, `analyze` stores its full input as one fact instead of invoking an LLM extractor. Its simple relevance score is for application tests, not production search-quality evaluation.
 
 ### Context Manager
 
@@ -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
@@ -254,6 +254,7 @@ Create a new async client.
 | `await analyze(text, namespace?)` | Extract and store facts |
 | `await ask(question, limit?, namespace?)` | Ask a question answered using memories |
 | `await restore(namespace, limit?)` | Restore a namespace |
+| `await forget(namespace?)` | Delete index rows for the namespace. Walrus blobs stay. Returns `ForgetResult`. |
 | `await list_namespaces(cursor?, limit?)` | List namespaces that hold memories; paginate on `has_more` |
 | `await health()` | Check server health |
 | `await remember_manual(opts)` | Store encrypted payload + pre-computed vector |

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/README.md

@@ -106,7 +106,7 @@ async def test_memory_flow():
     assert "dark mode" in result.results[0].text
 ```
 
-The mock supports remember/job polling, bulk remember, recall, analyze, embed, ask, health, restore, list_namespaces, `forget(blob_id)`, and `clear(namespace)`. For deterministic behavior, `analyze` stores its full input as one fact instead of invoking an LLM extractor. Its simple relevance score is for application tests, not production search-quality evaluation.
+The mock supports remember/job polling, bulk remember, recall, analyze, embed, ask, health, restore, list_namespaces, `forget(blob_id)` (synchronous per-blob deletion returning `bool`), `forget_namespace(namespace?)` (namespace erasure returning `ForgetResult`), and `clear(namespace?)`. For deterministic behavior, `analyze` stores its full input as one fact instead of invoking an LLM extractor. Its simple relevance score is for application tests, not production search-quality evaluation.
 
 ### Context Manager
 
@@ -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
@@ -213,6 +213,7 @@ Create a new async client.
 | `await analyze(text, namespace?)` | Extract and store facts |
 | `await ask(question, limit?, namespace?)` | Ask a question answered using memories |
 | `await restore(namespace, limit?)` | Restore a namespace |
+| `await forget(namespace?)` | Delete index rows for the namespace. Walrus blobs stay. Returns `ForgetResult`. |
 | `await list_namespaces(cursor?, limit?)` | List namespaces that hold memories; paginate on `has_more` |
 | `await health()` | Check server health |
 | `await remember_manual(opts)` | Store encrypted payload + pre-computed vector |

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/memwal/__init__.py

@@ -27,6 +27,7 @@ from .client import (
     MemWalClockDriftError,
     MemWalCompatibilityError,
     MemWalError,
+    MemWalJsonBodyError,
     MemWalRateLimited,
     MemWalRememberJobFailed,
     MemWalRememberJobNotFound,
@@ -43,6 +44,7 @@ from .types import (
     AskMemory,
     AskResult,
     EmbedResult,
+    ForgetResult,
     HealthResult,
     MemWalConfig,
     NamespacesResult,
@@ -83,6 +85,7 @@ __all__ = [
     "MemWalError",
     "MemWalCompatibilityError",
     "MemWalClockDriftError",
+    "MemWalJsonBodyError",
     "MemWalRateLimited",
     "MemWalRememberJobFailed",
     "MemWalRememberJobNotFound",
@@ -118,6 +121,7 @@ __all__ = [
     "AnalyzedFact",
     "HealthResult",
     "RestoreResult",
+    "ForgetResult",
     "NamespaceSummary",
     "NamespacesResult",
     "ScoringWeights",
@@ -128,4 +132,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.2.2.dev2"
+__version__ = "0.2.2.dev4"

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/memwal/client.py

@@ -51,6 +51,7 @@ from .types import (
     AskMemory,
     AskResult,
     EmbedResult,
+    ForgetResult,
     HealthResult,
     MemWalConfig,
     NamespacesResult,
@@ -675,7 +676,7 @@ class MemWal:
         if generated_key:
             self._pending_remember_keys.pop(request_identity, None)
         return RememberAcceptedResult(
-            job_id=data["job_id"],
+            job_id=_require(data, "job_id", "POST /api/remember"),
             status=data.get("status", "pending"),
         )
 
@@ -717,6 +718,10 @@ class MemWal:
                 # Status is metadata. No SEAL decrypt, so no session. Matches TS.
                 include_seal_session=False,
             )
+        except MemWalJsonBodyError as err:
+            if err.status != 404:
+                raise
+            data = None
         except (json.JSONDecodeError, UnicodeDecodeError):
             data = None
         if not isinstance(data, dict):
@@ -800,6 +805,10 @@ class MemWal:
                         )
                     else:
                         raise
+            except MemWalJsonBodyError as err:
+                if err.status == 404:
+                    raise MemWalRememberJobNotFound(job_id) from None
+                raise
             except (json.JSONDecodeError, UnicodeDecodeError):
                 raise MemWalRememberJobNotFound(job_id) from None
             except _HttpStatusError as err:
@@ -1244,6 +1253,30 @@ class MemWal:
             dropped_count=dropped,
         )
 
+    async def forget(self, namespace: Optional[str] = None) -> ForgetResult:
+        """Delete this owner's index rows for ``namespace``.
+
+        Wraps ``POST /api/forget``. Walrus blobs persist; the rows stop being
+        retrievable. Defaults to the client namespace.
+        """
+        resolved_namespace = self._resolve_namespace(namespace)
+        data = await self._signed_request(
+            "POST",
+            "/api/forget",
+            {"namespace": resolved_namespace},
+            include_seal_session=False,
+        )
+        endpoint = "POST /api/forget"
+        return ForgetResult(
+            deleted=int(_require(data, "deleted", endpoint)),
+            namespace=_require(data, "namespace", endpoint),
+            owner=_require(data, "owner", endpoint),
+        )
+
+    async def forget_namespace(self, namespace: Optional[str] = None) -> ForgetResult:
+        """Alias for :meth:`forget` matching :meth:`MemWalMock.forget_namespace`."""
+        return await self.forget(namespace)
+
     async def analyze(
         self,
         text: str,
@@ -1562,7 +1595,7 @@ class MemWal:
             raise _destroyed_client_error()
         if response.status_code != 200:
             raise MemWalError(f"Health check failed: {response.status_code}")
-        data = response.json()
+        data = _parse_json_response(response, "GET /health")
         return HealthResult(
             status=_require(data, "status", "GET /health"),
             version=_require(data, "version", "GET /health"),
@@ -1690,7 +1723,7 @@ class MemWal:
             if self._destroyed:
                 raise _destroyed_client_error()
             if version_response.status_code == 200:
-                metadata = version_response.json()
+                metadata = _parse_json_response(version_response, "GET /version")
             elif version_response.status_code in (404, 405):
                 health_response = await self._http.get(f"{self._server_url}/health")
                 if self._destroyed:
@@ -1701,7 +1734,7 @@ class MemWal:
                         f"GET /version returned {version_response.status_code}, "
                         f"and GET /health returned {health_response.status_code}"
                     )
-                metadata = health_response.json()
+                metadata = _parse_json_response(health_response, "GET /health")
             else:
                 raise MemWalError(
                     "Walrus Memory compatibility check failed: "
@@ -1723,7 +1756,11 @@ class MemWal:
         if response.status_code != 200:
             raise MemWalError(f"GET /config returned {response.status_code}")
 
-        data = response.json()
+        data = _parse_json_response(response, "GET /config")
+        if not isinstance(data, dict):
+            raise MemWalError(
+                f"GET /config response was {type(data).__name__}, expected an object"
+            )
         package_id = data.get("packageId")
         network = data.get("network")
         sui_rpc_url = data.get("suiRpcUrl")
@@ -1758,8 +1795,9 @@ class MemWal:
         )
         if response.status_code != 200:
             raise MemWalError(f"Sui GraphQL returned {response.status_code}")
-        body = response.json()
-        obj = (body.get("data") or {}).get("object")
+        body = _parse_json_response(response, f"POST {graphql_url}")
+        data = body.get("data") if isinstance(body, dict) else None
+        obj = data.get("object") if isinstance(data, dict) else None
         if not isinstance(obj, dict) or obj.get("version") is None:
             raise MemWalError(f"Sui GraphQL could not resolve package {package_id}")
         return obj["version"]
@@ -1780,8 +1818,8 @@ class MemWal:
         if response.status_code != 200:
             raise MemWalError(f"sui_getObject returned {response.status_code}")
 
-        body = response.json()
-        result = body.get("result", {})
+        body = _parse_json_response(response, f"POST {sui_rpc_url}")
+        result = body.get("result", {}) if isinstance(body, dict) else {}
         version = None
         if isinstance(result, dict):
             data = result.get("data")
@@ -1904,7 +1942,7 @@ class MemWal:
         )
         if self._destroyed:
             raise _destroyed_client_error()
-        owner = data.get("owner")
+        owner = data.get("owner") if isinstance(data, dict) else None
         if not owner:
             raise MemWalError(
                 "Walrus Memory could not resolve this account's owner address "
@@ -2052,7 +2090,15 @@ class MemWal:
                 retry_after=response.headers.get("retry-after"),
             )
 
-        return response.json()
+        endpoint = f"{method_upper} {path}"
+        data = _parse_json_response(response, endpoint)
+        if response.status_code != 404 and not isinstance(data, dict):
+            raise MemWalJsonBodyError(
+                status=response.status_code,
+                endpoint=endpoint,
+                body=response.text,
+            )
+        return data
 
 
 class MemWalError(Exception):
@@ -2076,6 +2122,71 @@ class MemWalClockDriftError(MemWalError):
     pass
 
 
+class MemWalJsonBodyError(MemWalError):
+    """Raised when an HTTP response that should carry JSON has an empty or non-JSON body."""
+
+    def __init__(
+        self,
+        status: int,
+        endpoint: str,
+        body: str,
+        *,
+        empty: bool = False,
+    ) -> None:
+        redacted = _redact_internal_urls(body.strip()[:200]) if body else ""
+        if empty:
+            message = (
+                f"MemWal ({endpoint}): HTTP {status} response had an empty body; "
+                "expected JSON"
+            )
+        elif redacted:
+            message = (
+                f"MemWal ({endpoint}): HTTP {status} response was not JSON: "
+                f"{redacted}"
+            )
+        else:
+            message = f"MemWal ({endpoint}): HTTP {status} response was not JSON"
+        super().__init__(message)
+        self.status = status
+        self.endpoint = endpoint
+        self.body = body
+
+
+def _parse_json_response(response: httpx.Response, endpoint: str) -> Any:
+    """Decode a JSON response body or raise :class:`MemWalJsonBodyError` (#1219).
+
+    Mirrors the TypeScript SDK's ``jsonBodyError`` guard (#1201 / #1207): an
+    empty or non-JSON 2xx response from a relayer or proxy in front of one
+    surfaces as a :class:`MemWalError` naming the endpoint and HTTP status
+    rather than Python's raw :class:`json.JSONDecodeError` or
+    :class:`UnicodeDecodeError`.
+    """
+    try:
+        return response.json()
+    except UnicodeDecodeError as exc:
+        raise MemWalJsonBodyError(
+            status=response.status_code,
+            endpoint=endpoint,
+            body="",
+        ) from exc
+    except (json.JSONDecodeError, ValueError) as exc:
+        doc = getattr(exc, "doc", None)
+        if isinstance(doc, str):
+            raw = doc
+        else:
+            try:
+                raw = response.text
+            except UnicodeDecodeError:
+                raw = ""
+        is_empty = not raw or not raw.strip()
+        raise MemWalJsonBodyError(
+            status=response.status_code,
+            endpoint=endpoint,
+            body=raw,
+            empty=is_empty,
+        ) from exc
+
+
 def _redact_internal_urls(text: str) -> str:
     return re.sub(
         r"https?://(?:(?:[\w-]+\.)*localhost|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|\[::1\]|0\.0\.0\.0)(?::\d+)?[^\s)\]>'\"]*",
@@ -2396,6 +2507,14 @@ class MemWalSync:
         :class:`RecallParams` for the recommended object-style call)."""
         return self._run(self._inner.recall(query, limit, namespace, max_distance))
 
+    def forget(self, namespace: Optional[str] = None) -> ForgetResult:
+        """Synchronous version of :meth:`MemWal.forget`."""
+        return self._run(self._inner.forget(namespace))
+
+    def forget_namespace(self, namespace: Optional[str] = None) -> ForgetResult:
+        """Synchronous version of :meth:`MemWal.forget_namespace`."""
+        return self._run(self._inner.forget_namespace(namespace))
+
     def analyze(
         self,
         text: str,

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/memwal/compatibility.py

@@ -12,6 +12,12 @@ SUPPORTED_RELAYER_API_MAJOR = 1
 def compatibility_error(metadata: Dict[str, Any], server_url: str) -> Optional[str]:
     """Return an actionable error string when relayer metadata is unsupported."""
 
+    if not isinstance(metadata, dict):
+        return (
+            f"Walrus Memory relayer at {server_url} does not expose compatibility metadata. "
+            "Upgrade the relayer to a version that serves GET /version, or use an older SDK."
+        )
+
     api_version = metadata.get("apiVersion")
     relayer_version = metadata.get("relayerVersion")
     min_supported = metadata.get("minSupportedSdk")

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/memwal/mock.py

@@ -20,6 +20,7 @@ from .types import (
     AskMemory,
     AskResult,
     EmbedResult,
+    ForgetResult,
     HealthResult,
     NamespacesResult,
     NamespaceSummary,
@@ -497,6 +498,13 @@ class MemWalMock:
                 return True
         return False
 
+    async def forget_namespace(self, namespace: Optional[str] = None) -> ForgetResult:
+        resolved = self._namespace if namespace is None else namespace
+        if not resolved:
+            raise ValueError("namespace cannot be empty")
+        deleted = self.clear(resolved)
+        return ForgetResult(deleted=deleted, namespace=resolved, owner=self._owner)
+
     def clear(self, namespace: Optional[str] = None) -> int:
         removed = [
             memory
@@ -717,6 +725,9 @@ class MemWalMockSync:
     def forget(self, blob_id: str) -> bool:
         return self._inner.forget(blob_id)
 
+    def forget_namespace(self, namespace: Optional[str] = None) -> ForgetResult:
+        return self._run(self._inner.forget_namespace(namespace))
+
     def clear(self, namespace: Optional[str] = None) -> int:
         return self._inner.clear(namespace)
 

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/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",
 }
 
@@ -84,6 +84,14 @@ class RememberResult:
     namespace: str
 
 
+@dataclass
+class ForgetResult:
+    """Result from POST /api/forget. Walrus blobs are not deleted."""
+
+    deleted: int
+    namespace: str
+    owner: str
+
 @dataclass
 class RecallMemory:
     """A single recalled memory."""

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/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.dev2 → memwal-0.2.2.dev4}/pyproject.toml

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

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/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.dev2 → memwal-0.2.2.dev4}/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.dev4/tests/test_forget.py

@@ -0,0 +1,91 @@
+import pytest
+
+from memwal import ForgetResult, MemWal, MemWalSync
+
+
+class CaptureMemWal(MemWal):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.captured = []
+
+    async def _ensure_compatible_relayer(self):
+        return {
+            "apiVersion": "1.0.0",
+            "relayerVersion": "capture",
+            "minSupportedSdk": {"python": "0.0.0"},
+        }
+
+    async def _signed_request(
+        self,
+        method,
+        path,
+        body,
+        accepted_statuses=(200,),
+        include_seal_session=True,
+        *args,
+        **kwargs,
+    ):
+        self.captured.append((method, path, body))
+        return {"deleted": 2, "namespace": body["namespace"], "owner": "0xowner"}
+
+
+@pytest.mark.asyncio
+async def test_forget_posts_the_client_namespace():
+    client = CaptureMemWal.create(
+        key="11" * 32,
+        account_id="0x" + "ab" * 32,
+        server_url="https://relayer.example",
+        namespace="profile",
+    )
+    result = await client.forget()
+    assert result == ForgetResult(deleted=2, namespace="profile", owner="0xowner")
+    alias = await client.forget_namespace("custom")
+    assert alias == ForgetResult(deleted=2, namespace="custom", owner="0xowner")
+    assert client.captured == [
+        ("POST", "/api/forget", {"namespace": "profile"}),
+        ("POST", "/api/forget", {"namespace": "custom"}),
+    ]
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_forget_rejects_empty_namespace_without_deleting_default():
+    client = CaptureMemWal.create(
+        key="11" * 32,
+        account_id="0x" + "ab" * 32,
+        server_url="https://relayer.example",
+        namespace="important",
+    )
+    with pytest.raises(ValueError, match="namespace cannot be empty"):
+        await client.forget("")
+    with pytest.raises(ValueError, match="namespace cannot be empty"):
+        await client.forget_namespace("")
+    assert client.captured == []
+    await client.close()
+
+
+def test_sync_client_has_forget():
+    assert hasattr(MemWal, "forget")
+    assert hasattr(MemWalSync, "forget")
+    assert hasattr(MemWal, "forget_namespace")
+    assert hasattr(MemWalSync, "forget_namespace")
+    sync_client = MemWalSync(
+        CaptureMemWal.create(
+            key="11" * 32,
+            account_id="0x" + "ab" * 32,
+            server_url="https://relayer.example",
+            namespace="important",
+        )
+    )
+    with pytest.raises(ValueError, match="namespace cannot be empty"):
+        sync_client.forget("")
+    with pytest.raises(ValueError, match="namespace cannot be empty"):
+        sync_client.forget_namespace("")
+    assert sync_client._inner.captured == []
+    assert sync_client.forget_namespace("archive") == ForgetResult(
+        deleted=2, namespace="archive", owner="0xowner"
+    )
+    assert sync_client._inner.captured == [
+        ("POST", "/api/forget", {"namespace": "archive"})
+    ]
+    sync_client.close()

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/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.dev4/tests/test_json_body.py

@@ -0,0 +1,310 @@
+"""Empty or non-JSON 2xx responses raise ``MemWalJsonBodyError`` (#1219).
+
+Mirrors ``packages/sdk/test/json-body.test.mjs`` (#1201 / #1207): a relayer or
+proxy in front of one that answers 2xx with an empty or non-JSON body must
+raise a :class:`MemWalError` naming the endpoint and HTTP status rather than
+leaking Python's raw :class:`json.JSONDecodeError`.
+"""
+
+from __future__ import annotations
+
+import json
+
+import httpx
+import nacl.signing
+import pytest
+import respx
+
+from memwal import (
+    MemWal,
+    MemWalCompatibilityError,
+    MemWalError,
+    MemWalJsonBodyError,
+    MemWalRememberJobNotFound,
+    MemWalSync,
+)
+from memwal.types import RememberManualOptions
+from memwal.utils import bytes_to_hex
+
+_SERVER = "https://relayer.example"
+_KEY_HEX = bytes_to_hex(bytes(nacl.signing.SigningKey(b"\x11" * 32)))
+_VERSION_JSON = {
+    "apiVersion": "1.0.0",
+    "relayerVersion": "1.0.0",
+    "minSupportedSdk": {"python": "0.1.0"},
+}
+
+
+def _client() -> MemWal:
+    return MemWal.create(key=_KEY_HEX, account_id="0x1", server_url=_SERVER)
+
+
+def _mock_version() -> None:
+    respx.get(f"{_SERVER}/version").mock(
+        return_value=httpx.Response(200, json=_VERSION_JSON)
+    )
+
+
+def _mock_seal_session_prereqs() -> None:
+    _mock_version()
+    respx.get(f"{_SERVER}/config").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "packageId": "0xpkg",
+                "network": "testnet",
+                "suiRpcUrl": "https://fullnode.testnet.sui.io:443",
+            },
+        )
+    )
+    respx.post("https://graphql.testnet.sui.io/graphql").mock(
+        return_value=httpx.Response(
+            200,
+            json={"data": {"object": {"version": 1}}},
+        )
+    )
+
+
+@respx.mock
+async def test_health_rejects_empty_200_with_memwal_error() -> None:
+    respx.get(f"{_SERVER}/health").mock(return_value=httpx.Response(200, content=b"   "))
+    with pytest.raises(MemWalJsonBodyError) as exc:
+        await _client().health()
+    assert isinstance(exc.value, MemWalError)
+    assert not isinstance(exc.value, json.JSONDecodeError)
+    assert exc.value.status == 200
+    assert exc.value.endpoint == "GET /health"
+    assert "GET /health" in str(exc.value)
+    assert "empty body; expected JSON" in str(exc.value)
+
+
+@respx.mock
+async def test_health_rejects_non_json_200_and_redacts_internal_urls() -> None:
+    respx.get(f"{_SERVER}/health").mock(
+        return_value=httpx.Response(
+            200,
+            text="<html>upstream http://localhost:8080/health failed</html>",
+            headers={"content-type": "text/html"},
+        )
+    )
+    with pytest.raises(MemWalJsonBodyError) as exc:
+        await _client().health()
+    assert isinstance(exc.value, MemWalError)
+    assert not isinstance(exc.value, json.JSONDecodeError)
+    assert exc.value.status == 200
+    assert exc.value.endpoint == "GET /health"
+    assert "response was not JSON" in str(exc.value)
+    assert "localhost" not in str(exc.value)
+    assert "[internal]" in str(exc.value)
+
+
+@respx.mock
+async def test_compatibility_rejects_empty_and_non_json_version_200() -> None:
+    route = respx.get(f"{_SERVER}/version")
+    for content, expected_phrase in (
+        (b"", "empty body; expected JSON"),
+        (b"nope", "response was not JSON"),
+    ):
+        route.mock(return_value=httpx.Response(200, content=content))
+        with pytest.raises(MemWalJsonBodyError) as exc:
+            await _client().compatibility()
+        assert exc.value.status == 200
+        assert exc.value.endpoint == "GET /version"
+        assert expected_phrase in str(exc.value)
+
+
+@respx.mock
+async def test_compatibility_rejects_non_json_health_fallback_200() -> None:
+    respx.get(f"{_SERVER}/version").mock(return_value=httpx.Response(404))
+    respx.get(f"{_SERVER}/health").mock(
+        return_value=httpx.Response(200, text="bad gateway html")
+    )
+    with pytest.raises(MemWalJsonBodyError) as exc:
+        await _client().compatibility()
+    assert exc.value.status == 200
+    assert exc.value.endpoint == "GET /health"
+    assert "response was not JSON" in str(exc.value)
+
+
+@respx.mock
+async def test_compatibility_rejects_non_object_json_200() -> None:
+    respx.get(f"{_SERVER}/version").mock(return_value=httpx.Response(200, content=b"null"))
+    with pytest.raises(MemWalCompatibilityError):
+        await _client().compatibility()
+
+
+@respx.mock
+async def test_config_and_package_version_reject_non_json_200() -> None:
+    _mock_version()
+    respx.get(f"{_SERVER}/config").mock(return_value=httpx.Response(200, content=b""))
+    with pytest.raises(MemWalJsonBodyError) as exc:
+        await _client().recall("coffee")
+    assert exc.value.status == 200
+    assert exc.value.endpoint == "GET /config"
+    assert "empty body; expected JSON" in str(exc.value)
+
+    respx.get(f"{_SERVER}/config").mock(
+        return_value=httpx.Response(
+            200,
+            json={
+                "packageId": "0xpkg",
+                "network": "testnet",
+                "suiRpcUrl": "https://fullnode.testnet.sui.io:443",
+            },
+        )
+    )
+    respx.post("https://graphql.testnet.sui.io/graphql").mock(
+        return_value=httpx.Response(200, text="not-json")
+    )
+    with pytest.raises(MemWalJsonBodyError) as gql_exc:
+        await _client().recall("coffee")
+    assert gql_exc.value.status == 200
+    assert "graphql.testnet.sui.io" in gql_exc.value.endpoint
+    assert "response was not JSON" in str(gql_exc.value)
+
+
+@respx.mock
+async def test_remember_rejects_empty_202_without_polling() -> None:
+    _mock_seal_session_prereqs()
+    respx.post(f"{_SERVER}/api/remember").mock(
+        return_value=httpx.Response(202, content=b"")
+    )
+    poll_route = respx.get(url__regex=rf"^{_SERVER}/api/remember/.+").mock(
+        return_value=httpx.Response(200, json={"job_id": "j1", "status": "done"})
+    )
+
+    client = _client()
+    with pytest.raises(MemWalJsonBodyError) as exc:
+        await client.remember_and_wait("hello", timeout_ms=5_000)
+    assert exc.value.status == 202
+    assert exc.value.endpoint == "POST /api/remember"
+    assert "empty body; expected JSON" in str(exc.value)
+    assert poll_route.call_count == 0
+
+
+@respx.mock
+async def test_signed_requests_reject_empty_non_json_and_non_object_200() -> None:
+    _mock_seal_session_prereqs()
+    respx.post(f"{_SERVER}/api/stats").mock(
+        return_value=httpx.Response(200, json={"owner": "0xowner"})
+    )
+    ns_route = respx.get(f"{_SERVER}/v1/owners/0xowner/namespaces")
+    for body in (b"", b"<html>error</html>", b"null", b"[]"):
+        ns_route.mock(return_value=httpx.Response(200, content=body))
+        with pytest.raises(MemWalJsonBodyError) as exc:
+            await _client().list_namespaces()
+        assert exc.value.status == 200
+        assert exc.value.endpoint == "GET /v1/owners/0xowner/namespaces"
+
+    restore_route = respx.post(f"{_SERVER}/api/restore")
+    restore_route.mock(return_value=httpx.Response(200, content=b""))
+    with pytest.raises(MemWalJsonBodyError) as restore_exc:
+        await _client().restore("default")
+    assert restore_exc.value.status == 200
+    assert restore_exc.value.endpoint == "POST /api/restore"
+
+    manual_route = respx.post(f"{_SERVER}/api/remember/manual")
+    manual_route.mock(return_value=httpx.Response(200, text="nope"))
+    with pytest.raises(MemWalJsonBodyError) as manual_exc:
+        await _client().remember_manual(
+            RememberManualOptions(encrypted_data="ZGF0YQ==", vector=[0.1])
+        )
+    assert manual_exc.value.status == 200
+    assert manual_exc.value.endpoint == "POST /api/remember/manual"
+
+
+@respx.mock
+async def test_remember_status_distinguishes_200_non_json_from_404_non_json() -> None:
+    _mock_seal_session_prereqs()
+    route = respx.get(f"{_SERVER}/api/remember/job-1")
+
+    # 200 with empty or non-JSON body raises MemWalJsonBodyError
+    for content in (b"", b"<html>bad</html>"):
+        route.mock(return_value=httpx.Response(200, content=content))
+        with pytest.raises(MemWalJsonBodyError) as exc:
+            await _client().get_remember_status("job-1")
+        assert exc.value.status == 200
+        assert exc.value.endpoint == "GET /api/remember/job-1"
+
+        with pytest.raises(MemWalJsonBodyError) as wait_exc:
+            await _client().wait_for_remember_job(
+                "job-1", poll_interval_ms=0, timeout_ms=5_000
+            )
+        assert wait_exc.value.status == 200
+
+    # 404 with empty or non-JSON body remains not_found
+    route.mock(return_value=httpx.Response(404, content=b""))
+    status = await _client().get_remember_status("job-1")
+    assert status.status == "not_found"
+    with pytest.raises(MemWalRememberJobNotFound):
+        await _client().wait_for_remember_job(
+            "job-1", poll_interval_ms=0, timeout_ms=5_000
+        )
+
+
+@respx.mock
+def test_sync_client_surfaces_memwal_json_body_error() -> None:
+    respx.get(f"{_SERVER}/health").mock(return_value=httpx.Response(200, content=b""))
+    sync_client = MemWalSync.create(key=_KEY_HEX, account_id="0x1", server_url=_SERVER)
+    with pytest.raises(MemWalJsonBodyError) as exc:
+        sync_client.health()
+    assert exc.value.status == 200
+    assert exc.value.endpoint == "GET /health"
+
+
+@respx.mock
+async def test_health_rejects_malformed_utf8_inside_json_string() -> None:
+    route = respx.get(f"{_SERVER}/health")
+    for raw in (
+        b'{"status":"ok","version":"\xff"}',
+        b"\x80\x81\x82",
+    ):
+        route.mock(
+            return_value=httpx.Response(
+                200,
+                content=raw,
+                headers={"content-type": "application/json"},
+            )
+        )
+        with pytest.raises(MemWalJsonBodyError) as exc:
+            await _client().health()
+        assert isinstance(exc.value, MemWalError)
+        assert not isinstance(exc.value, UnicodeDecodeError)
+        assert exc.value.status == 200
+        assert exc.value.endpoint == "GET /health"
+        assert "response was not JSON" in str(exc.value)
+
+
+@respx.mock
+async def test_health_accepts_utf8_bom_and_utf16_json_bodies() -> None:
+    route = respx.get(f"{_SERVER}/health")
+    payload = '{"status":"ok","version":"0.2.2"}'
+    for encoded in (
+        b"\xef\xbb\xbf" + payload.encode("utf-8"),
+        payload.encode("utf-16"),
+        payload.encode("utf-16-le"),
+        payload.encode("utf-16-be"),
+    ):
+        route.mock(
+            return_value=httpx.Response(
+                200,
+                content=encoded,
+                headers={"content-type": "application/json"},
+            )
+        )
+        health = await _client().health()
+        assert health.status == "ok"
+        assert health.version == "0.2.2"
+
+    # BOM-only or UTF-16 whitespace-only payloads still surface as empty JSON body errors
+    for empty_encoded in (
+        b"\xef\xbb\xbf",
+        b"\xef\xbb\xbf   ",
+        "   ".encode("utf-16"),
+    ):
+        route.mock(return_value=httpx.Response(200, content=empty_encoded))
+        with pytest.raises(MemWalJsonBodyError) as exc:
+            await _client().health()
+        assert exc.value.status == 200
+        assert exc.value.endpoint == "GET /health"
+        assert "empty body; expected JSON" in str(exc.value)

{memwal-0.2.2.dev2 → memwal-0.2.2.dev4}/tests/test_mock.py

@@ -121,7 +121,18 @@ async def test_mock_supports_jobs_bulk_analyze_forget_and_clear():
 
     assert mock.forget("mock-blob-000001") is True
     assert mock.forget("missing") is False
-    assert mock.clear("one") == 1
+    assert (await mock.recall("single fact")).total == 0
+    assert (await mock.recall("bulk", namespace="one")).total == 1
+    assert (await mock.recall("bulk", namespace="two")).total == 1
+    assert (await mock.recall("durable analyzed fact", namespace="analysis")).total == 1
+    with pytest.raises(ValueError, match="namespace cannot be empty"):
+        await mock.forget_namespace("")
+    forgotten = await mock.forget_namespace("one")
+    assert forgotten.namespace == "one"
+    assert forgotten.deleted == 1
+    assert (await mock.recall("bulk", namespace="two")).total == 1
+    assert (await mock.recall("durable analyzed fact", namespace="analysis")).total == 1
+    assert mock.clear("one") == 0
     assert (await mock.recall("bulk", namespace="one")).total == 0
 
 
@@ -171,6 +182,17 @@ def test_sync_mock_wraps_core_flows_and_accepts_production_options():
     assert analyzed_wait.succeeded == 1
     assert recalled.results[0].text == "sync memory"
 
+    assert recalled.total == 5
+    assert mock.forget(stored.blob_id) is True
+    assert mock.forget("missing-blob") is False
+    assert mock.recall("sync").total == 4
+    with pytest.raises(ValueError, match="namespace cannot be empty"):
+        mock.forget_namespace("")
+    forgotten = mock.forget_namespace("sync")
+    assert forgotten.namespace == "sync"
+    assert forgotten.deleted == 4
+    assert mock.recall("sync").total == 0
+
 
 def test_sync_mock_polling_and_analyze_signatures_match_production():
     methods = (
@@ -182,6 +204,7 @@ def test_sync_mock_polling_and_analyze_signatures_match_production():
         "remember_bulk_and_wait",
         "analyze",
         "analyze_and_wait",
+        "forget_namespace",
     )
 
     def parameter_contract(method):