memwal 0.1.0.dev0__tar.gz → 0.1.0.dev2__tar.gz

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memwal
-Version: 0.1.0.dev0
+Version: 0.1.0.dev2
 Summary: Python SDK for MemWal — Privacy-first AI memory with Ed25519 signing
 Project-URL: Homepage, https://memwal.ai
 Project-URL: Documentation, https://docs.memwal.ai
@@ -130,6 +130,32 @@ async with MemWal.create(
     await memwal.remember("I prefer dark mode")
 ```
 
+## Environment Presets
+
+Instead of hardcoding a relayer URL, pass `env` to target a hosted relayer.
+Same shorthand as the TypeScript SDK and MCP package.
+
+```python
+from memwal import MemWal
+
+memwal = MemWal.create(
+    key=os.environ["MEMWAL_KEY"],
+    account_id=os.environ["MEMWAL_ACCOUNT_ID"],
+    env="prod",   # prod | dev | staging | local
+)
+```
+
+| `env` | Relayer URL |
+|-------|-------------|
+| `prod` | `https://relayer.memwal.ai` |
+| `dev` | `https://relayer.dev.memwal.ai` |
+| `staging` | `https://relayer.staging.memwal.ai` |
+| `local` | `http://127.0.0.1:8000` |
+
+Precedence: an explicit non-default **`server_url` wins over `env`**, which wins
+over the default. An unknown preset raises `ValueError`. `env` is also accepted
+by `MemWalSync.create`, `with_memwal_langchain`, and `with_memwal_openai`.
+
 ## AI Middleware
 
 ### LangChain
@@ -201,10 +227,10 @@ Create a new async client.
 Every request is signed with Ed25519:
 
 ```
-message = f"{timestamp}.{method}.{path}.{sha256(body)}.{nonce}.{account_id}"
+message = f"{timestamp}.{method}.{path}.{sha256(body)}"
 ```
 
-Headers sent: `x-public-key`, `x-signature`, `x-timestamp`, `x-nonce`, `x-delegate-key`, `x-account-id`.
+Headers sent: `x-public-key`, `x-signature`, `x-timestamp`, `x-delegate-key`, `x-account-id`.
 
 ## License
 

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/README.md

@@ -91,6 +91,32 @@ async with MemWal.create(
     await memwal.remember("I prefer dark mode")
 ```
 
+## Environment Presets
+
+Instead of hardcoding a relayer URL, pass `env` to target a hosted relayer.
+Same shorthand as the TypeScript SDK and MCP package.
+
+```python
+from memwal import MemWal
+
+memwal = MemWal.create(
+    key=os.environ["MEMWAL_KEY"],
+    account_id=os.environ["MEMWAL_ACCOUNT_ID"],
+    env="prod",   # prod | dev | staging | local
+)
+```
+
+| `env` | Relayer URL |
+|-------|-------------|
+| `prod` | `https://relayer.memwal.ai` |
+| `dev` | `https://relayer.dev.memwal.ai` |
+| `staging` | `https://relayer.staging.memwal.ai` |
+| `local` | `http://127.0.0.1:8000` |
+
+Precedence: an explicit non-default **`server_url` wins over `env`**, which wins
+over the default. An unknown preset raises `ValueError`. `env` is also accepted
+by `MemWalSync.create`, `with_memwal_langchain`, and `with_memwal_openai`.
+
 ## AI Middleware
 
 ### LangChain
@@ -162,10 +188,10 @@ Create a new async client.
 Every request is signed with Ed25519:
 
 ```
-message = f"{timestamp}.{method}.{path}.{sha256(body)}.{nonce}.{account_id}"
+message = f"{timestamp}.{method}.{path}.{sha256(body)}"
 ```
 
-Headers sent: `x-public-key`, `x-signature`, `x-timestamp`, `x-nonce`, `x-delegate-key`, `x-account-id`.
+Headers sent: `x-public-key`, `x-signature`, `x-timestamp`, `x-delegate-key`, `x-account-id`.
 
 ## License
 

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/examples/async_remember_demo.py

@@ -25,6 +25,7 @@ import os
 import sys
 import time
 from pathlib import Path
+from typing import Optional
 
 
 def _load_env() -> None:
@@ -49,6 +50,7 @@ sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from memwal import (  # noqa: E402
     MemWal,
+    MemWalRememberJobFailed,
     RememberBulkItem,
     RememberBulkOptions,
 )

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/memwal/__init__.py

@@ -33,6 +33,7 @@ from .client import (
 from .middleware import with_memwal_langchain, with_memwal_openai
 from .utils import delegate_key_to_sui_address, delegate_key_to_public_key
 from .types import (
+    ENV_PRESETS,
     AnalyzedFact,
     AnalyzeResult,
     AnalyzeWaitResult,
@@ -81,6 +82,7 @@ __all__ = [
     "withMemWal",
     # Types
     "MemWalConfig",
+    "ENV_PRESETS",
     "AskMemory",
     "AskResult",
     "RememberResult",
@@ -108,4 +110,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.1.0.dev0"
+__version__ = "0.1.0.dev2"

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/memwal/client.py

@@ -29,7 +29,7 @@ import asyncio
 import json
 import random
 import time
-from typing import Any, Dict, List, Optional, Sequence, TypeVar
+from typing import Any, Dict, List, Optional, Sequence, Tuple, TypeVar
 
 import httpx
 
@@ -55,6 +55,7 @@ from .types import (
     RememberBulkResult,
     RememberBulkStatusItem,
     RememberBulkStatusResult,
+    RememberJobStatus,
     RememberManualOptions,
     RememberManualResult,
     RememberResult,
@@ -128,16 +129,21 @@ class MemWal:
         cls,
         key: str,
         account_id: str,
-        server_url: str = "https://relayer.memwal.ai",
+        server_url: str = "http://localhost:8000",
         namespace: str = "default",
+        env: Optional[str] = None,
     ) -> "MemWal":
         """Create a new MemWal client instance.
 
         Args:
             key: Ed25519 private key hex string (the delegate key).
             account_id: MemWalAccount object ID on Sui.
-            server_url: Server URL (default: ``https://relayer.memwal.ai``).
+            server_url: Server URL (default: ``http://localhost:8000``).
             namespace: Default namespace for memory isolation (default: ``"default"``).
+            env: Optional relayer preset — ``"prod"``, ``"dev"``, ``"staging"``,
+                or ``"local"``. Resolves ``server_url`` to the matching hosted
+                relayer unless an explicit non-default ``server_url`` is given.
+                Precedence: explicit ``server_url`` > ``env`` > default.
 
         Returns:
             A configured :class:`MemWal` instance.
@@ -147,6 +153,7 @@ class MemWal:
             account_id=account_id,
             server_url=server_url,
             namespace=namespace,
+            env=env,
         )
         return cls(config)
 
@@ -708,14 +715,12 @@ class MemWal:
     ) -> Dict[str, Any]:
         """Make a signed request to the server.
 
-        Signature format:
-            ``{timestamp}.{method}.{path}.{body_sha256}.{nonce}.{account_id}``
+        Signature format: ``{timestamp}.{method}.{path}.{body_sha256}``
 
         Headers sent:
             - ``x-public-key``: Ed25519 public key hex
             - ``x-signature``: Ed25519 signature hex
             - ``x-timestamp``: Unix seconds string
-            - ``x-nonce``: UUID v4 replay-protection nonce
             - ``x-delegate-key``: Private key hex
             - ``x-account-id``: MemWalAccount object ID
             - ``Content-Type``: application/json
@@ -842,22 +847,27 @@ class MemWalSync:
         cls,
         key: str,
         account_id: str,
-        server_url: str = "https://relayer.memwal.ai",
+        server_url: str = "http://localhost:8000",
         namespace: str = "default",
+        env: Optional[str] = None,
     ) -> "MemWalSync":
         """Create a synchronous MemWal client.
 
-        Same parameters as :meth:`MemWal.create`.
+        Same parameters as :meth:`MemWal.create` (including the ``env``
+        relayer preset).
         """
         inner = MemWal.create(
             key=key,
             account_id=account_id,
             server_url=server_url,
             namespace=namespace,
+            env=env,
         )
         return cls(inner)
 
     def _run(self, coro: Any) -> Any:
+        import asyncio
+
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/memwal/middleware.py

@@ -137,12 +137,13 @@ def with_memwal_langchain(
     llm: "BaseChatModel",
     key: str,
     account_id: str,
-    server_url: str = "https://relayer.memwal.ai",
+    server_url: str = "http://localhost:8000",
     namespace: str = "default",
     max_memories: int = 5,
     auto_save: bool = True,
     min_relevance: float = 0.3,
     debug: bool = False,
+    env: Optional[str] = None,
 ) -> "BaseChatModel":
     """Wrap a LangChain ``BaseChatModel`` with MemWal memory management.
 
@@ -163,6 +164,8 @@ def with_memwal_langchain(
         auto_save: Auto-save new facts from conversation.
         min_relevance: Minimum similarity score (0-1) to include a memory.
         debug: Enable debug logging.
+        env: Optional relayer preset (``"prod"`` / ``"dev"`` / ``"staging"`` /
+            ``"local"``). Same precedence as :meth:`MemWal.create`.
 
     Returns:
         A wrapped ``BaseChatModel`` that automatically uses MemWal memory.
@@ -181,6 +184,7 @@ def with_memwal_langchain(
         account_id=account_id,
         server_url=server_url,
         namespace=namespace,
+        env=env,
     )
 
     log = logger.debug if not debug else logger.warning
@@ -254,6 +258,8 @@ def with_memwal_langchain(
         messages: List[List[BaseMessage]], *args: Any, **kwargs: Any
     ) -> ChatResult:
         # For sync generate, we inject memories synchronously via asyncio.run
+        import asyncio
+
         enriched = []
         for msg_list in messages:
             try:
@@ -290,12 +296,13 @@ def with_memwal_openai(
     client: Any,
     key: str,
     account_id: str,
-    server_url: str = "https://relayer.memwal.ai",
+    server_url: str = "http://localhost:8000",
     namespace: str = "default",
     max_memories: int = 5,
     auto_save: bool = True,
     min_relevance: float = 0.3,
     debug: bool = False,
+    env: Optional[str] = None,
 ) -> Any:
     """Wrap an OpenAI client with MemWal memory management.
 
@@ -318,6 +325,8 @@ def with_memwal_openai(
         auto_save: Auto-save new facts from conversation.
         min_relevance: Minimum similarity score (0-1) to include a memory.
         debug: Enable debug logging.
+        env: Optional relayer preset (``"prod"`` / ``"dev"`` / ``"staging"`` /
+            ``"local"``). Same precedence as :meth:`MemWal.create`.
 
     Returns:
         The same client, with ``chat.completions.create`` wrapped to use MemWal.
@@ -327,6 +336,7 @@ def with_memwal_openai(
         account_id=account_id,
         server_url=server_url,
         namespace=namespace,
+        env=env,
     )
 
     log = logger.debug if not debug else logger.warning
@@ -408,6 +418,8 @@ def _wrap_sync_openai(
     original_create = client.chat.completions.create
 
     def patched_create(*args: Any, **kwargs: Any) -> Any:
+        import asyncio
+
         messages = kwargs.get("messages") or (args[0] if args else None)
         if messages is None:
             return original_create(*args, **kwargs)

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/memwal/types.py

@@ -15,6 +15,21 @@ from typing import List, Optional
 # Config
 # ============================================================
 
+#: Default ``server_url`` when neither an explicit URL nor an ``env`` preset
+#: is supplied. Kept as a module constant so ``__post_init__`` can tell an
+#: untouched default apart from an explicitly-passed custom URL.
+DEFAULT_SERVER_URL = "http://localhost:8000"
+
+#: Named relayer environments. Mirrors the TypeScript SDK / MCP package
+#: ``--prod`` / ``--dev`` / ``--staging`` / ``--local`` presets so the same
+#: shorthand works across every MemWal client.
+ENV_PRESETS = {
+    "prod": "https://relayer.memwal.ai",
+    "dev": "https://relayer.dev.memwal.ai",
+    "staging": "https://relayer.staging.memwal.ai",
+    "local": "http://127.0.0.1:8000",
+}
+
 
 @dataclass
 class MemWalConfig:
@@ -23,14 +38,33 @@ class MemWalConfig:
     Attributes:
         key: Ed25519 private key (hex string). This is the delegate key from app.memwal.com.
         account_id: MemWalAccount object ID on Sui.
-        server_url: Server URL (default: https://relayer.memwal.ai).
+        server_url: Server URL (default: http://localhost:8000). An explicit
+            non-default value always wins over ``env``.
         namespace: Default namespace for memory isolation (default: "default").
+        env: Optional relayer preset — one of ``"prod"``, ``"dev"``,
+            ``"staging"``, ``"local"``. Resolves ``server_url`` to the matching
+            hosted relayer when ``server_url`` is left at its default.
+            Precedence: explicit ``server_url`` > ``env`` > default.
     """
 
     key: str
     account_id: str
-    server_url: str = "https://relayer.memwal.ai"
+    server_url: str = DEFAULT_SERVER_URL
     namespace: str = "default"
+    env: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        if self.env is not None:
+            preset = ENV_PRESETS.get(self.env)
+            if preset is None:
+                valid = ", ".join(sorted(ENV_PRESETS))
+                raise ValueError(
+                    f"Unknown env preset {self.env!r}. Valid presets: {valid}"
+                )
+            # Explicit, non-default server_url takes precedence over the
+            # preset; only fill from the preset when server_url is untouched.
+            if self.server_url == DEFAULT_SERVER_URL:
+                self.server_url = preset
 
 
 # ============================================================

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/pyproject.toml

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

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/tests/test_client.py

@@ -16,7 +16,7 @@ import respx
 
 from memwal.client import MemWal, MemWalError
 from memwal.types import RecallManualOptions, RememberManualOptions
-from memwal.utils import bytes_to_hex, sha256_hex
+from memwal.utils import build_signature_message, bytes_to_hex, sha256_hex
 
 # ============================================================
 # Fixtures
@@ -122,7 +122,14 @@ class TestRemember:
         timestamp = headers["x-timestamp"]
         body_hash = sha256_hex(body_str)
         nonce = headers["x-nonce"]
-        message = f"{timestamp}.POST./api/remember.{body_hash}.{nonce}.{_TEST_ACCOUNT_ID}"
+        message = build_signature_message(
+            timestamp=timestamp,
+            method="POST",
+            path="/api/remember",
+            body_sha256=body_hash,
+            nonce=nonce,
+            account_id=headers["x-account-id"],
+        )
 
         # Verify signature
         verify_key = nacl.signing.VerifyKey(bytes.fromhex(headers["x-public-key"]))

memwal-0.1.0.dev2/tests/test_env_presets.py

@@ -0,0 +1,71 @@
+"""Tests for the relayer environment presets (prod/dev/staging/local).
+
+Pure config resolution — no network. Mirrors the precedence rule documented
+in the README: explicit non-default ``server_url`` > ``env`` > default.
+"""
+
+import pytest
+
+from memwal import ENV_PRESETS, MemWal, MemWalConfig, MemWalSync
+from memwal.types import DEFAULT_SERVER_URL
+
+# A throwaway but structurally valid 32-byte Ed25519 seed (64 hex chars).
+KEY = "11" * 32
+ACCOUNT = "0x" + "ab" * 32
+
+
+@pytest.mark.parametrize(
+    "env,expected",
+    [
+        ("prod", "https://relayer.memwal.ai"),
+        ("dev", "https://relayer.dev.memwal.ai"),
+        ("staging", "https://relayer.staging.memwal.ai"),
+        ("local", "http://127.0.0.1:8000"),
+    ],
+)
+def test_env_preset_resolves(env, expected):
+    cfg = MemWalConfig(key=KEY, account_id=ACCOUNT, env=env)
+    assert cfg.server_url == expected
+    assert ENV_PRESETS[env] == expected
+
+
+def test_explicit_server_url_overrides_env():
+    cfg = MemWalConfig(
+        key=KEY,
+        account_id=ACCOUNT,
+        server_url="https://my.custom.relayer",
+        env="prod",
+    )
+    assert cfg.server_url == "https://my.custom.relayer"
+
+
+def test_no_env_keeps_default():
+    cfg = MemWalConfig(key=KEY, account_id=ACCOUNT)
+    assert cfg.server_url == DEFAULT_SERVER_URL
+
+
+def test_unknown_env_raises():
+    with pytest.raises(ValueError, match="Unknown env preset"):
+        MemWalConfig(key=KEY, account_id=ACCOUNT, env="prdo")
+
+
+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.memwal.ai"
+
+
+def test_sync_create_threads_env_through():
+    client = MemWalSync.create(key=KEY, account_id=ACCOUNT, env="dev")
+    assert client._inner._server_url == "https://relayer.dev.memwal.ai"
+
+
+def test_explicit_default_url_with_env_still_takes_preset():
+    # Passing the default URL explicitly is indistinguishable from not
+    # passing it — documented edge: the preset still applies.
+    cfg = MemWalConfig(
+        key=KEY,
+        account_id=ACCOUNT,
+        server_url=DEFAULT_SERVER_URL,
+        env="prod",
+    )
+    assert cfg.server_url == "https://relayer.memwal.ai"

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/tests/test_integration.py

@@ -40,12 +40,14 @@ import hashlib
 import json
 import os
 import time
+import uuid
 
 import httpx
 import nacl.signing
 import pytest
 
 from memwal.client import MemWal, MemWalError, MemWalSync
+from memwal.utils import build_signature_message, bytes_to_hex
 
 # ── Config ───────────────────────────────────────────────────────────────────
 
@@ -77,7 +79,15 @@ def _raw_signed_request(
     body_bytes = json.dumps(body, separators=(",", ":")).encode()
     body_hash = hashlib.sha256(body_bytes).hexdigest()
     timestamp = timestamp_override or str(int(time.time()))
-    message = f"{timestamp}.{method.upper()}.{path}.{body_hash}"
+    nonce = str(uuid.uuid4())
+    message = build_signature_message(
+        timestamp=timestamp,
+        method=method.upper(),
+        path=path,
+        body_sha256=body_hash,
+        nonce=nonce,
+        account_id=ACCOUNT_ID or "0x0",
+    )
     signed = signing_key.sign(message.encode())
     signature_hex = signed.signature.hex()
     pub_key_hex = pub_key_override or signing_key.verify_key.encode().hex()
@@ -92,6 +102,8 @@ def _raw_signed_request(
                 "x-public-key": pub_key_hex,
                 "x-signature": signature_hex,
                 "x-timestamp": timestamp,
+                "x-nonce": nonce,
+                "x-account-id": ACCOUNT_ID or "0x0",
             },
         )
 

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/tests/test_middleware.py

@@ -16,10 +16,13 @@ with ``respx`` and all LLM responses are mocked with ``unittest.mock``.
 from __future__ import annotations
 
 import asyncio
-from unittest.mock import AsyncMock, MagicMock
+import json
+from typing import Any, List
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import httpx
 import nacl.signing
+import pytest
 import respx
 
 from memwal.middleware import (

{memwal-0.1.0.dev0 → memwal-0.1.0.dev2}/tests/test_signing.py

@@ -131,16 +131,16 @@ class TestBuildSignatureMessage:
     """Tests for build_signature_message -- the exact format the server expects."""
 
     def test_format_matches_spec(self) -> None:
-        """Signature message includes timestamp, method, path, body hash, nonce, and account."""
+        """Signature message MUST match the canonical 6-part server format."""
         result = build_signature_message(
             timestamp="1700000000",
             method="POST",
             path="/api/remember",
             body_sha256="abc123",
-            nonce="nonce-1",
-            account_id="0xabc",
+            nonce="550e8400-e29b-41d4-a716-446655440000",
+            account_id="0xabc123",
         )
-        assert result == "1700000000.POST./api/remember.abc123.nonce-1.0xabc"
+        assert result == "1700000000.POST./api/remember.abc123.550e8400-e29b-41d4-a716-446655440000.0xabc123"
 
     def test_get_method(self) -> None:
         result = build_signature_message(
@@ -148,8 +148,8 @@ class TestBuildSignatureMessage:
             method="GET",
             path="/health",
             body_sha256="e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-            nonce="nonce-2",
-            account_id="0xdef",
+            nonce="550e8400-e29b-41d4-a716-446655440000",
+            account_id="0xabc123",
         )
         parts = result.split(".")
         assert parts[0] == "1700000001"
@@ -168,15 +168,10 @@ class TestBuildSignatureMessage:
         path = "/api/remember"
         body = json.dumps({"text": "hello", "namespace": "default"}, separators=(",", ":"))
         body_hash = sha256_hex(body)
+        nonce = "550e8400-e29b-41d4-a716-446655440000"
+        account_id = "0xabc123"
 
-        message = build_signature_message(
-            timestamp,
-            method,
-            path,
-            body_hash,
-            nonce="nonce-3",
-            account_id="0xabc",
-        )
+        message = build_signature_message(timestamp, method, path, body_hash, nonce=nonce, account_id=account_id)
         sig_hex, pub_hex = sign_message(message, signing_key)
 
         # Verify (as the server would)
@@ -194,11 +189,11 @@ class TestBuildSignatureMessage:
             "POST",
             "/api/remember",
             body_hash,
-            nonce="nonce-4",
-            account_id="0xabc",
+            nonce="550e8400-e29b-41d4-a716-446655440000",
+            account_id="0xabc123",
         )
 
-        # Extract the hash from the message
+        # Extract the hash from the canonical 6-part message
         extracted_hash = message.split(".")[3]
         assert extracted_hash == body_hash
         assert extracted_hash == hashlib.sha256(body_str.encode("utf-8")).hexdigest()