memwal 0.1.2.dev1__tar.gz → 0.1.2.dev3__tar.gz

memwal-0.1.2.dev3/CHANGELOG.md

@@ -0,0 +1,34 @@
+# memwal
+
+## 0.1.2
+
+### Added
+
+- Added `max_distance` to async and sync `recall()`.
+- Added credential verification helper.
+
+### Changed
+
+- Updated docs/examples to use `MEMWAL_PRIVATE_KEY`.
+- Rebranded package metadata and documentation from MemWal to Walrus Memory.
+
+### Fixed
+
+- Made `401` relayer errors more actionable.
+
+## 0.1.1
+
+### Added
+
+- Added relayer `env` presets.
+- Added compatibility checks and `compatibility()` helpers.
+
+## 0.1.0
+
+### Initial Release
+
+- `MemWal` async client and `MemWalSync` sync wrapper
+- Memory APIs: `remember`, `recall`, `analyze`, `ask`, `restore`, `health`
+- Async job helpers for remember, bulk remember, and analyze
+- LangChain/OpenAI middleware and delegate-key utilities
+- Ed25519 delegate-key auth with namespace-scoped memory isolation

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: memwal
-Version: 0.1.2.dev1
-Summary: Python SDK for MemWal — Privacy-first AI memory with Ed25519 signing
+Version: 0.1.2.dev3
+Summary: Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing
 Project-URL: Homepage, https://memwal.ai
 Project-URL: Documentation, https://docs.memwal.ai
 Project-URL: Repository, https://github.com/MystenLabs/MemWal
-Author: MemWal Team
+Author: Walrus Memory Team
 License-Expression: MIT
-Keywords: ai,ed25519,memory,memwal,privacy,sui,walrus
+Keywords: ai,ed25519,memory,memwal,privacy,sui,walrus,walrus-memory
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -37,9 +37,9 @@ Provides-Extra: openai
 Requires-Dist: openai>=1.0.0; extra == 'openai'
 Description-Content-Type: text/markdown
 
-# memwal
+# Walrus Memory Python SDK
 
-Python SDK for [MemWal](https://memwal.ai) — Privacy-first AI memory with Ed25519 signing.
+Python SDK for [Walrus Memory](https://memwal.ai) — Privacy-first AI memory with Ed25519 signing.
 
 All data processing (encryption, embedding, Walrus storage) happens server-side in a TEE. The SDK signs requests with your Ed25519 delegate key and sends text over HTTPS.
 
@@ -63,11 +63,11 @@ Set your environment variables first:
 
 ```bash
 export MEMWAL_PRIVATE_KEY="your-ed25519-delegate-private-key-hex"
-export MEMWAL_ACCOUNT_ID="0x-your-memwal-account-id"
+export MEMWAL_ACCOUNT_ID="0x-your-walrus-memory-account-id"
 export MEMWAL_SERVER_URL="https://relayer.memwal.ai"
 ```
 
-`MEMWAL_PRIVATE_KEY` is the delegate private key from the MemWal dashboard and
+`MEMWAL_PRIVATE_KEY` is the delegate private key from the Walrus Memory dashboard and
 must stay server-side.
 
 ### Async (recommended)

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

@@ -1,6 +1,6 @@
-# memwal
+# Walrus Memory Python SDK
 
-Python SDK for [MemWal](https://memwal.ai) — Privacy-first AI memory with Ed25519 signing.
+Python SDK for [Walrus Memory](https://memwal.ai) — Privacy-first AI memory with Ed25519 signing.
 
 All data processing (encryption, embedding, Walrus storage) happens server-side in a TEE. The SDK signs requests with your Ed25519 delegate key and sends text over HTTPS.
 
@@ -24,11 +24,11 @@ Set your environment variables first:
 
 ```bash
 export MEMWAL_PRIVATE_KEY="your-ed25519-delegate-private-key-hex"
-export MEMWAL_ACCOUNT_ID="0x-your-memwal-account-id"
+export MEMWAL_ACCOUNT_ID="0x-your-walrus-memory-account-id"
 export MEMWAL_SERVER_URL="https://relayer.memwal.ai"
 ```
 
-`MEMWAL_PRIVATE_KEY` is the delegate private key from the MemWal dashboard and
+`MEMWAL_PRIVATE_KEY` is the delegate private key from the Walrus Memory dashboard and
 must stay server-side.
 
 ### Async (recommended)

{memwal-0.1.2.dev1 → memwal-0.1.2.dev3}/examples/.env.example

@@ -1,10 +1,10 @@
 # Local server (default) or remote relayer
 MEMWAL_SERVER_URL=http://localhost:8000
-# Ed25519 delegate private key (64-hex). Get from MemWal dashboard.
+# Ed25519 delegate private key (64-hex). Get from Walrus Memory dashboard.
 MEMWAL_PRIVATE_KEY=21b423e72282dcc47805de48ef9130331b642667b7b2a5cd621767928205e360
 # Optional: paste the dashboard delegate public key so verification can catch mismatches.
 MEMWAL_DELEGATE_PUBLIC_KEY=
-# MemWalAccount object ID on Sui (the wallet's account)
+# Walrus Memory account object ID on Sui (the wallet's account)
 MEMWAL_ACCOUNT_ID=0x8a1121b8f95d79e68bd07efaf71689ce6fd832b369cdb1b2a943ec7beb822392
 # Namespace for these test memories
 MEMWAL_NAMESPACE=python-sdk-example

{memwal-0.1.2.dev1 → memwal-0.1.2.dev3}/examples/verify_credentials.py

@@ -47,7 +47,7 @@ def main() -> None:
             "You may have pasted a public key or a key from another account."
         )
 
-    print("MemWal credentials look parseable.")
+    print("Walrus Memory credentials look parseable.")
     print(f"Derived delegate public key: {derived_public_key}")
     if account_id:
         print(f"Account ID: {account_id}")

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

@@ -1,5 +1,5 @@
 """
-memwal — Privacy-first AI memory SDK
+Walrus Memory — Privacy-first AI memory SDK
 
 Ed25519 delegate key auth + server-side TEE processing.
 
@@ -32,7 +32,6 @@ from .client import (
     MemWalSync,
 )
 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,
@@ -61,7 +60,9 @@ from .types import (
     RememberManualResult,
     RememberResult,
     RestoreResult,
+    ScoringWeights,
 )
+from .utils import delegate_key_to_public_key, delegate_key_to_sui_address
 
 # JS-style alias for developers coming from the TypeScript SDK
 withMemWal = with_memwal_langchain
@@ -105,6 +106,7 @@ __all__ = [
     "AnalyzedFact",
     "HealthResult",
     "RestoreResult",
+    "ScoringWeights",
     "RememberManualOptions",
     "RememberManualResult",
     "RecallManualOptions",
@@ -112,4 +114,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.1.2.dev1"
+__version__ = "0.1.2.dev3"

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

@@ -1,7 +1,7 @@
 """
-memwal — SDK Client
+Walrus Memory — SDK Client
 
-Ed25519 delegate key based client that communicates with the MemWal
+Ed25519 delegate key based client that communicates with the Walrus Memory
 Rust server (TEE). All data processing (encryption, embedding, Walrus)
 happens server-side -- the SDK just signs requests and sends text.
 
@@ -58,7 +58,6 @@ from .types import (
     RememberBulkResult,
     RememberBulkStatusItem,
     RememberBulkStatusResult,
-    RememberJobStatus,
     RememberManualOptions,
     RememberManualResult,
     RememberResult,
@@ -124,7 +123,7 @@ def _is_transient_polling_status(status: int) -> bool:
 
 
 class MemWal:
-    """Async-native MemWal client.
+    """Async-native Walrus Memory client.
 
     All API methods are ``async``. For synchronous usage, wrap calls with
     ``asyncio.run()`` or use the :class:`MemWalSync` convenience wrapper.
@@ -152,11 +151,11 @@ class MemWal:
         namespace: str = "default",
         env: Optional[str] = None,
     ) -> "MemWal":
-        """Create a new MemWal client instance.
+        """Create a new Walrus Memory client instance.
 
         Args:
             key: Ed25519 private key hex string (the delegate key).
-            account_id: MemWalAccount object ID on Sui.
+            account_id: Walrus Memory account object ID on Sui.
             server_url: Server URL (default: ``http://localhost:8000``).
             namespace: Default namespace for memory isolation (default: ``"default"``).
             env: Optional relayer preset — ``"prod"``, ``"dev"``, ``"staging"``,
@@ -728,14 +727,18 @@ class MemWal:
         Returns:
             :class:`RecallManualResult` with blob_id + distance pairs.
         """
+        body: Dict[str, Any] = {
+            "vector": opts.vector,
+            "limit": opts.limit,
+            "namespace": opts.namespace or self._namespace,
+        }
+        if opts.scoring_weights is not None:
+            body["scoring_weights"] = opts.scoring_weights.to_wire()
+
         data = await self._signed_request(
             "POST",
             "/api/recall/manual",
-            {
-                "vector": opts.vector,
-                "limit": opts.limit,
-                "namespace": opts.namespace or self._namespace,
-            },
+            body,
             include_seal_session=False,
         )
         hits = [
@@ -774,14 +777,14 @@ class MemWal:
                 health_response = await self._http.get(f"{self._server_url}/health")
                 if health_response.status_code != 200:
                     raise MemWalError(
-                        "MemWal compatibility check failed: "
+                        "Walrus Memory compatibility check failed: "
                         f"GET /version returned {version_response.status_code}, "
                         f"and GET /health returned {health_response.status_code}"
                     )
                 metadata = health_response.json()
             else:
                 raise MemWalError(
-                    "MemWal compatibility check failed: "
+                    "Walrus Memory compatibility check failed: "
                     f"GET /version returned {version_response.status_code}"
                 )
 
@@ -840,7 +843,8 @@ class MemWal:
                     version = obj.get("version")
         if str(version) != "1":
             raise MemWalError(
-                f"SEAL package {package_id} must be at version 1 to build x-seal-session, got {version!r}"
+                f"SEAL package {package_id} must be at version 1 to build "
+                f"x-seal-session, got {version!r}"
             )
 
     async def _build_seal_session_inner(self) -> str:
@@ -920,7 +924,7 @@ class MemWal:
             - ``x-timestamp``: Unix seconds string
             - ``x-nonce``: UUID v4 replay-protection nonce
             - ``x-seal-session``: Base64-encoded exported session envelope
-            - ``x-account-id``: MemWalAccount object ID
+            - ``x-account-id``: Walrus Memory account object ID
             - ``Content-Type``: application/json
         """
         import uuid
@@ -969,7 +973,7 @@ class MemWal:
             err_text = response.text
             if response.status_code == 426:
                 raise MemWalCompatibilityError(
-                    "MemWal relayer rejected this SDK as unsupported "
+                    "Walrus Memory relayer rejected this SDK as unsupported "
                     f"(HTTP 426 Upgrade Required). Relayer response: "
                     f"{err_text[:300] or 'upgrade required'}"
                 )
@@ -982,7 +986,7 @@ class MemWal:
 
 
 class MemWalError(Exception):
-    """Exception raised for MemWal API errors."""
+    """Exception raised for Walrus Memory API errors."""
 
     pass
 
@@ -1005,7 +1009,7 @@ class _HttpStatusError(MemWalError):
         if status == 401:
             super().__init__(AUTH_REJECTED_MESSAGE)
         else:
-            super().__init__(f"MemWal API error ({status}): {body}")
+            super().__init__(f"Walrus Memory API error ({status}): {body}")
         self.status = status
         self.body = body
 
@@ -1068,7 +1072,7 @@ class MemWalSync:
         namespace: str = "default",
         env: Optional[str] = None,
     ) -> "MemWalSync":
-        """Create a synchronous MemWal client.
+        """Create a synchronous Walrus Memory client.
 
         Same parameters as :meth:`MemWal.create` (including the ``env``
         relayer preset).

{memwal-0.1.2.dev1 → memwal-0.1.2.dev3}/memwal/compatibility.py

@@ -18,33 +18,33 @@ def compatibility_error(metadata: Dict[str, Any], server_url: str) -> Optional[s
 
     if not api_version or not relayer_version or not isinstance(min_supported, dict):
         return (
-            f"MemWal relayer at {server_url} does not expose compatibility metadata. "
+            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_major = _semver_major(str(api_version))
     if api_major is None:
-        return f'MemWal relayer at {server_url} returned invalid apiVersion "{api_version}".'
+        return f'Walrus Memory relayer at {server_url} returned invalid apiVersion "{api_version}".'
 
     if api_major != SUPPORTED_RELAYER_API_MAJOR:
         return (
-            "This MemWal Python SDK supports relayer API "
+            "This Walrus Memory Python SDK supports relayer API "
             f"{SUPPORTED_RELAYER_API_MAJOR}.x, but {server_url} reports apiVersion "
             f"{api_version}. Upgrade or downgrade the SDK/relayer pair."
         )
 
     min_python = min_supported.get("python")
     if not isinstance(min_python, str):
-        return f"MemWal relayer at {server_url} did not report minSupportedSdk.python."
+        return f"Walrus Memory relayer at {server_url} did not report minSupportedSdk.python."
     if _parse_semver(min_python) is None:
         return (
-            f'MemWal relayer at {server_url} returned invalid '
+            f'Walrus Memory relayer at {server_url} returned invalid '
             f'minSupportedSdk.python "{min_python}".'
         )
 
     if _compare_semver(MEMWAL_PYTHON_COMPATIBILITY_VERSION, min_python) < 0:
         return (
-            f"MemWal relayer at {server_url} requires Python SDK >= {min_python}, "
+            f"Walrus Memory relayer at {server_url} requires Python SDK >= {min_python}, "
             f"but this package supports the {MEMWAL_PYTHON_COMPATIBILITY_VERSION} "
             "compatibility baseline. Upgrade memwal or use an older compatible relayer."
         )

{memwal-0.1.2.dev1 → memwal-0.1.2.dev3}/memwal/middleware.py

@@ -1,5 +1,5 @@
 """
-memwal — AI Middleware
+Walrus Memory — AI Middleware
 
 Wraps LangChain and OpenAI SDK clients with automatic memory management.
 Before each LLM call, relevant memories are recalled and injected.
@@ -145,7 +145,7 @@ def with_memwal_langchain(
     debug: bool = False,
     env: Optional[str] = None,
 ) -> "BaseChatModel":
-    """Wrap a LangChain ``BaseChatModel`` with MemWal memory management.
+    """Wrap a LangChain ``BaseChatModel`` with Walrus Memory management.
 
     Before each call:
         - Recall relevant memories for the last user message
@@ -157,8 +157,8 @@ def with_memwal_langchain(
     Args:
         llm: A LangChain ``BaseChatModel`` instance.
         key: Ed25519 delegate key (hex).
-        account_id: MemWalAccount object ID.
-        server_url: MemWal server URL.
+        account_id: Walrus Memory account object ID.
+        server_url: Walrus Memory server URL.
         namespace: Default namespace.
         max_memories: Max memories to inject per request.
         auto_save: Auto-save new facts from conversation.
@@ -168,7 +168,7 @@ def with_memwal_langchain(
             ``"local"``). Same precedence as :meth:`MemWal.create`.
 
     Returns:
-        A wrapped ``BaseChatModel`` that automatically uses MemWal memory.
+        A wrapped ``BaseChatModel`` that automatically uses Walrus Memory.
     """
     try:
         from langchain_core.messages import HumanMessage, SystemMessage  # noqa: F811
@@ -208,7 +208,7 @@ def with_memwal_langchain(
                 return messages
 
             memory_context = _format_memories(relevant)
-            log(f"[MemWal] Found {len(relevant)} relevant memories")
+            log(f"[Walrus Memory] Found {len(relevant)} relevant memories")
 
             # Insert memory system message before the last user message
             result = list(messages)
@@ -226,7 +226,7 @@ def with_memwal_langchain(
 
             return result
         except Exception as e:
-            log(f"[MemWal] Memory search failed: {e}")
+            log(f"[Walrus Memory] Memory search failed: {e}")
             return messages
 
     async def _post_analyze(messages: List[BaseMessage]) -> None:
@@ -238,7 +238,7 @@ def with_memwal_langchain(
             try:
                 await memwal.analyze(user_text, namespace)
             except Exception as e:
-                log(f"[MemWal] Auto-save failed: {e}")
+                log(f"[Walrus Memory] Auto-save failed: {e}")
 
     async def patched_agenerate(
         messages: List[List[BaseMessage]], *args: Any, **kwargs: Any
@@ -304,7 +304,7 @@ def with_memwal_openai(
     debug: bool = False,
     env: Optional[str] = None,
 ) -> Any:
-    """Wrap an OpenAI client with MemWal memory management.
+    """Wrap an OpenAI client with Walrus Memory management.
 
     Works with both ``openai.OpenAI`` (sync) and ``openai.AsyncOpenAI`` (async).
 
@@ -318,8 +318,8 @@ def with_memwal_openai(
     Args:
         client: An ``openai.OpenAI`` or ``openai.AsyncOpenAI`` instance.
         key: Ed25519 delegate key (hex).
-        account_id: MemWalAccount object ID.
-        server_url: MemWal server URL.
+        account_id: Walrus Memory account object ID.
+        server_url: Walrus Memory server URL.
         namespace: Default namespace.
         max_memories: Max memories to inject per request.
         auto_save: Auto-save new facts from conversation.
@@ -329,7 +329,7 @@ def with_memwal_openai(
             ``"local"``). Same precedence as :meth:`MemWal.create`.
 
     Returns:
-        The same client, with ``chat.completions.create`` wrapped to use MemWal.
+        The same client, with ``chat.completions.create`` wrapped to use Walrus Memory.
     """
     memwal = MemWal.create(
         key=key,
@@ -379,14 +379,14 @@ def _wrap_async_openai(
                 ]
                 if relevant:
                     memory_context = _format_memories(relevant)
-                    log(f"[MemWal] Found {len(relevant)} relevant memories")
+                    log(f"[Walrus Memory] Found {len(relevant)} relevant memories")
                     messages = _inject_openai_memory(list(messages), memory_context)
                     if "messages" in kwargs:
                         kwargs["messages"] = messages
                     elif args:
                         args = (messages,) + args[1:]
             except Exception as e:
-                log(f"[MemWal] Memory search failed: {e}")
+                log(f"[Walrus Memory] Memory search failed: {e}")
 
         result = await original_create(*args, **kwargs)
 
@@ -396,7 +396,7 @@ def _wrap_async_openai(
                 try:
                     await memwal.analyze(user_text, namespace)
                 except Exception as e:
-                    log(f"[MemWal] Auto-save failed: {e}")
+                    log(f"[Walrus Memory] Auto-save failed: {e}")
 
             _fire_and_forget(_analyze())
 
@@ -437,14 +437,14 @@ def _wrap_sync_openai(
                 ]
                 if relevant:
                     memory_context = _format_memories(relevant)
-                    log(f"[MemWal] Found {len(relevant)} relevant memories")
+                    log(f"[Walrus Memory] Found {len(relevant)} relevant memories")
                     messages = _inject_openai_memory(list(messages), memory_context)
                     if "messages" in kwargs:
                         kwargs["messages"] = messages
                     elif args:
                         args = (messages,) + args[1:]
             except Exception as e:
-                log(f"[MemWal] Memory search failed: {e}")
+                log(f"[Walrus Memory] Memory search failed: {e}")
 
         result = original_create(*args, **kwargs)
 
@@ -454,7 +454,7 @@ def _wrap_sync_openai(
                 try:
                     await memwal.analyze(user_text, namespace)
                 except Exception as e:
-                    log(f"[MemWal] Auto-save failed: {e}")
+                    log(f"[Walrus Memory] Auto-save failed: {e}")
 
             _fire_and_forget(_analyze())
 

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

@@ -1,9 +1,9 @@
 """
-memwal — Core Types
+Walrus Memory — Core Types
 
 Dataclasses for all API request options and response types.
 Ed25519 delegate key based SDK that communicates with
-the MemWal Rust server (TEE).
+the Walrus Memory Rust server (TEE).
 """
 
 from __future__ import annotations
@@ -22,7 +22,7 @@ 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.
+#: shorthand works across every Walrus Memory client.
 ENV_PRESETS = {
     "prod": "https://relayer.memwal.ai",
     "dev": "https://relayer.dev.memwal.ai",
@@ -33,11 +33,12 @@ ENV_PRESETS = {
 
 @dataclass
 class MemWalConfig:
-    """Configuration for creating a MemWal client.
+    """Configuration for creating a Walrus Memory client.
 
     Attributes:
-        key: Ed25519 private key (hex string). This is the delegate key from app.memwal.com.
-        account_id: MemWalAccount object ID on Sui.
+        key: Ed25519 private key (hex string). This is the delegate key from the
+            Walrus Memory dashboard.
+        account_id: Walrus Memory account object ID on Sui.
         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").
@@ -99,6 +100,37 @@ class RecallResult:
     total: int
 
 
+@dataclass
+class ScoringWeights:
+    """Optional composite-scoring weights for recall ranking.
+
+    Attributes:
+        semantic: Weight applied to semantic similarity (default: 1).
+        recency: Weight applied to recency decay (default: 0).
+        recency_half_life_days: Half-life for the recency term, in days (default: 30).
+        importance: Weight applied to memory importance (default: 0).
+    """
+
+    semantic: Optional[float] = None
+    recency: Optional[float] = None
+    recency_half_life_days: Optional[float] = None
+    importance: Optional[float] = None
+
+    def to_wire(self) -> Dict[str, float]:
+        """Return the snake_case payload expected by the relayer."""
+
+        payload: Dict[str, float] = {}
+        if self.semantic is not None:
+            payload["semantic"] = self.semantic
+        if self.recency is not None:
+            payload["recency"] = self.recency
+        if self.recency_half_life_days is not None:
+            payload["recency_half_life_days"] = self.recency_half_life_days
+        if self.importance is not None:
+            payload["importance"] = self.importance
+        return payload
+
+
 @dataclass
 class AnalyzedFact:
     """A single extracted fact."""
@@ -212,11 +244,13 @@ class RecallManualOptions:
         vector: Pre-computed query embedding vector.
         limit: Max number of results (default: 10).
         namespace: Namespace (default: config namespace or "default").
+        scoring_weights: Optional composite-scoring weights applied before returning hits.
     """
 
     vector: List[float]
     limit: int = 10
     namespace: Optional[str] = None
+    scoring_weights: Optional[ScoringWeights] = None
 
 
 @dataclass

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

@@ -1,5 +1,5 @@
 """
-memwal — Shared Utilities
+Walrus Memory — Shared Utilities
 
 Crypto and encoding helpers for Ed25519 signing and SHA-256 hashing.
 Uses PyNaCl (nacl.signing) as the primary Ed25519 implementation.
@@ -119,7 +119,7 @@ def build_signature_message(
         path: URL path with query (e.g. ``"/api/remember"``).
         body_sha256: SHA-256 hex digest of the JSON body string.
         nonce: UUID v4 sent as the ``x-nonce`` header (required).
-        account_id: MemWalAccount object ID sent as ``x-account-id``
+        account_id: Walrus Memory account object ID sent as ``x-account-id``
             (required; empty string here will mismatch on server).
     """
     return f"{timestamp}.{method}.{path}.{body_sha256}.{nonce}.{account_id}"

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

@@ -4,15 +4,15 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memwal"
-version = "0.1.2.dev1"
-description = "Python SDK for MemWal — Privacy-first AI memory with Ed25519 signing"
+version = "0.1.2.dev3"
+description = "Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.9"
 authors = [
-    { name = "MemWal Team" },
+    { name = "Walrus Memory Team" },
 ]
-keywords = ["memwal", "ai", "memory", "ed25519", "privacy", "walrus", "sui"]
+keywords = ["memwal", "walrus-memory", "ai", "memory", "ed25519", "privacy", "walrus", "sui"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-MemWal Python SDK — Test Runner
+Walrus Memory Python SDK — Test Runner
 
 Runs all tests grouped by category and prints a clean summary.
 
@@ -77,7 +77,7 @@ def status(passed: int, failed: int) -> str:
 
 def print_header() -> None:
     print()
-    print(f"{BOLD}{CYAN}  MemWal Python SDK — Test Suite{RESET}")
+    print(f"{BOLD}{CYAN}  Walrus Memory Python SDK — Test Suite{RESET}")
     print(f"  {DIM}Server: {SERVER_URL}{RESET}")
     print(f"  {DIM}Auth:   {'✓ credentials set' if HAS_KEY else '✗ no key (integration tests skipped)'}{RESET}")
     print()

{memwal-0.1.2.dev1 → memwal-0.1.2.dev3}/tests/test_client.py

@@ -17,7 +17,7 @@ import pytest
 import respx
 
 from memwal.client import MemWal, MemWalCompatibilityError, MemWalError
-from memwal.types import RecallManualOptions, RememberManualOptions
+from memwal.types import RecallManualOptions, RememberManualOptions, ScoringWeights
 from memwal.utils import build_signature_message, bytes_to_hex, sha256_hex
 
 # ============================================================
@@ -95,7 +95,7 @@ def decode_seal_session_header(request: httpx.Request) -> dict[str, Any]:
 
 @pytest.fixture
 def memwal_client() -> MemWal:
-    """Create a MemWal client with a test key."""
+    """Create a Walrus Memory client with a test key."""
     return MemWal.create(
         key=_TEST_KEY_HEX,
         account_id=_TEST_ACCOUNT_ID,
@@ -327,7 +327,11 @@ class TestRecall:
             )
         )
 
-        result = await memwal_client.wait_for_remember_job("job-1", poll_interval_ms=0, timeout_ms=100)
+        result = await memwal_client.wait_for_remember_job(
+            "job-1",
+            poll_interval_ms=0,
+            timeout_ms=100,
+        )
 
         request = route.calls[0].request
         assert request.content == b""
@@ -583,6 +587,33 @@ class TestManualAPI:
         assert len(result.results) == 1
         assert result.results[0].blob_id == "b1"
 
+    @respx.mock
+    async def test_recall_manual_forwards_scoring_weights(self, memwal_client: MemWal) -> None:
+        _mock_version()
+        route = respx.post(f"{_TEST_SERVER}/api/recall/manual").mock(
+            return_value=httpx.Response(200, json={"results": [], "total": 0})
+        )
+
+        opts = RecallManualOptions(
+            vector=[0.1, 0.2, 0.3],
+            limit=5,
+            scoring_weights=ScoringWeights(
+                semantic=1.0,
+                recency=0.5,
+                recency_half_life_days=7.0,
+                importance=2.0,
+            ),
+        )
+        await memwal_client.recall_manual(opts)
+
+        body = json.loads(route.calls[0].request.content)
+        assert body["scoring_weights"] == {
+            "semantic": 1.0,
+            "recency": 0.5,
+            "recency_half_life_days": 7.0,
+            "importance": 2.0,
+        }
+
 
 class TestPublicKey:
     async def test_get_public_key_hex(self, memwal_client: MemWal) -> None:

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Integration tests for the MemWal Python SDK against a live server.
+Integration tests for the Walrus Memory Python SDK against a live server.
 
 Targets MEMWAL_SERVER_URL (default: https://relayer.dev.memwal.ai).
 

{memwal-0.1.2.dev1 → memwal-0.1.2.dev3}/tests/test_middleware.py

@@ -9,7 +9,7 @@ Covers:
   - _format_memories: output format
   - _inject_openai_memory: insertion position
 
-No actual LLM or MemWal server calls are made — all network traffic is mocked
+No actual LLM or Walrus Memory server calls are made — all network traffic is mocked
 with ``respx`` and all LLM responses are mocked with ``unittest.mock``.
 """